@apexnative/navigation 1.0.0-alpha.5 → 1.0.0-alpha.6

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [1.0.0-alpha.6](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.5...v1.0.0-alpha.6) (2026-10-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* leave the bottom edge of a screen free by default ([#49](https://github.com/apexnative/navigation/issues/49))
+
+### Features
+
+* a sheet's back preview on android, lighter tabs and top bar, the compatibility mode on ios 27 ([#46](https://github.com/apexnative/navigation/issues/46)) ([24d333d](https://github.com/apexnative/navigation/commit/24d333dd43fc5e056786f22dc8d7f1a0ff82a1ad))
+* leave the bottom edge of a screen free by default ([#49](https://github.com/apexnative/navigation/issues/49)) ([b6bb165](https://github.com/apexnative/navigation/commit/b6bb165152114fb2886bd3c4ee55560c418f0cbe))
+* **tabs:** choose whether a tab switch animates with bottomTabs.switchAnimation ([#52](https://github.com/apexnative/navigation/issues/52)) ([c6185b6](https://github.com/apexnative/navigation/commit/c6185b6b42574cff671def1ebdf8aa4f5e4be681))
+
+
+### Bug Fixes
+
+* an explicit top edge stays free under a large title ([#53](https://github.com/apexnative/navigation/issues/53)) ([188a89e](https://github.com/apexnative/navigation/commit/188a89e8d160c071f91cc010ed43ccc0683e12b3))
+* shared elements fly turned and scaled views the same way on ios and android ([#50](https://github.com/apexnative/navigation/issues/50)) ([bf63ab6](https://github.com/apexnative/navigation/commit/bf63ab624d33ff9295af297ce6506206b1bfa0e6))
+* the custom tab row moves with its tabs on android, and tab cells get selected and badge ([#51](https://github.com/apexnative/navigation/issues/51)) ([fd8f41d](https://github.com/apexnative/navigation/commit/fd8f41d2efd108741672220c54253a86704929a5))
+
+
+### Performance Improvements
+
+* **ios:** render a preview's screen when a press on its view starts ([#48](https://github.com/apexnative/navigation/issues/48)) ([4a57d1a](https://github.com/apexnative/navigation/commit/4a57d1aee1df7690dbde4c7d08dca2a70773d1f5))
+
 ## [1.0.0-alpha.5](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.4...v1.0.0-alpha.5) (2026-10-23)
 
 

package/README.md

@@ -97,7 +97,7 @@ navigation.push('Details', { props: { title: 'Order 42' } });
   each other: tabs of stacks, a stack in a modal, tabs in a side menu.
 - **Screen UI as options:** the top bar, bar buttons, search, the toolbar and the floating action button, the status
   bar and the system bars.
-- **No safe area code:** every screen keeps its content clear of the bars, the cutout and the home indicator by itself.
+- **No safe area code:** every screen keeps its top and sides clear of the bars and the cutout by itself; the bottom is free, and a list adds `useSafeAreaInsets().bottom`.
 - **Native screens:** SwiftUI, UIKit and Compose screens are pushed, presented and put in tabs the same way as React
   screens.
 - **One React tree when you want it:** each screen is its own React root by default; with `appProvider` all screens

package/android/CLAUDE.md

@@ -22,8 +22,8 @@ top-level folder. Main thread only, unless a line says otherwise.
   `Variant`, `ThemeColour`); `parsers/` reads them tolerantly from React Native data.
 - `react/`: the way in and out: `NavigationTurboModule`, `CommandRunner`, `CommandAnswer`, `ErrorTexts`,
   `OptionsCommands`, `PendingCalls` (a task behind the calls JavaScript made), `ReloadCoordinator`, `ReactGateway`,
-  `ReactView` (a React root), the stores (`ScreenInsets`, `ScreenRegions`, `ArrangementStates`, `Hinge`, `StartInfo`),
-  `LaunchLink`, `ScrollEvents`.
+  `ReactView` (a React root), the stores (`ScreenEnvironment`: a screen's insets, padding, regions and pair state;
+  `Hinge`, `StartInfo`), `ScreenRegions` (measures a screen's regions), `LaunchLink`, `ScrollEvents`.
 - `react/events/`: `AppearanceDispatcher`, `ScreenAppearance`, `EventEmitter`, `EventContract` (made by
   `scripts/contract.mjs`), `NavigationState`, `ComponentType`.
 - `viewcontrollers/viewcontroller/`: `ViewController` (the base of every node), `Presenter`, `IReactView` (what a
@@ -44,7 +44,7 @@ top-level folder. Main thread only, unless a line says otherwise.
 - `viewcontrollers/sidemenu/`: `SideMenuController`, `SideMenuMotion`, `SideMenuPresenter`, `SideMenuRules`.
 - `viewcontrollers/splitview/`, `arrangement/`: the split view and the pair (modules, plus the core's
   `SplitViewPresenter`).
-- `viewcontrollers/modal/`, `overlay/`: `ModalCoordinator`, `ModalRecord`, `ModalViews`, `ModalSheet`;
+- `viewcontrollers/modal/`, `overlay/`: `ModalCoordinator`, `ModalRecord`, `ModalViews`, `ModalSheet`, `SheetBack`;
   `OverlayCoordinator`, `OverlayRecord`, `OverlayViews`, `OverlayTouches`.
 - `views/`: Android views and animators, no rules: `component/`, `externalcomponent/`, `stack/` (`StackLayout`,
   `topbar/`, `fab/`), `bottomtabs/`, `sidemenu/`, `animations/` (curves, `SideAnimator`, `AnimationRules`), `element/`
@@ -78,7 +78,8 @@ top-level folder. Main thread only, unless a line says otherwise.
   `StackViews.kt`, `StackTransitions.kt`, `PreparedPushes.kt`; `views/stack/StackLayout.kt`, `ScreenEdge.kt` (the edge
   a moving screen extends); back: `NavigationActivity.kt`, `viewcontrollers/navigator/BackCallbackState.kt`; the
   preview of a pop during the back gesture (Android 14+): `StackController.BackGesture`, `BackPreview.kt`,
-  `stackPoppedByBack` of the layouts.
+  `stackPoppedByBack` of the layouts; of a sheet's dismissal: `viewcontrollers/modal/SheetBack.kt`,
+  `ModalCoordinator.backTargetSheet`, `ModalSheet.BackPreview`.
 - Stack FAB: `viewcontrollers/stack/fab/FabPresenter.kt`, `FabPlan.kt`, `FabPlacement.kt`; `views/stack/fab/`.
 - Top bar (title, buttons, menus, large title): `viewcontrollers/stack/topbar/TopBarPresenter.kt`, `TopBarRoom.kt`,
   `TopBarVisibility.kt`, `BarComponents.kt`, `ButtonPlaces.kt`, `LargeTitleCollapse.kt`, `BarRowTransition.kt`;
@@ -87,7 +88,7 @@ top-level folder. Main thread only, unless a line says otherwise.
   `views/stack/topbar/search/`.
 - Tabs: `viewcontrollers/bottomtabs/BottomTabsController.kt`, `BottomTabsPresenter.kt`, `TabSelection.kt`,
   `TabItems.kt`, `TabsRoom.kt`; `views/bottomtabs/`; `customrow/BottomTabsCustomRowOptions.kt`,
-  `viewcontrollers/bottomtabs/CustomTabRowPlacer.kt`.
+  `viewcontrollers/bottomtabs/CustomTabRowGeometry.kt`.
 - Modals and sheets: `viewcontrollers/modal/ModalCoordinator.kt`, `ModalRecord.kt`, `ModalViews.kt`, `ModalSheet.kt`,
   `ModalAnimations.kt`; `options/SheetOptions.kt`.
 - Overlays: `viewcontrollers/overlay/OverlayCoordinator.kt`, `OverlayViews.kt`, `OverlayTouches.kt`.
@@ -96,12 +97,13 @@ top-level folder. Main thread only, unless a line says otherwise.
 - Split view: `viewcontrollers/splitview/SplitViewController.kt`, `SplitViewLayout.kt`, `SplitPanes.kt`,
   `SplitViewPresenter.kt`; `StackCommands.showInColumn`.
 - Pair (arrangement): `viewcontrollers/arrangement/ArrangementController.kt`, `ArrangementPlanner.kt`,
-  `ArrangementLayout.kt`, `ArrangementDefinition.kt`; `react/ArrangementStates.kt`.
+  `ArrangementLayout.kt`, `ArrangementDefinition.kt`; the pair's state in `react/ScreenEnvironment.kt`.
 - Preview, key commands: iOS only. The options are parsed and merged (`options/PreviewOptions.kt`,
   `options/KeyCommandOptions.kt`) and not applied; `dismissPreview` does nothing.
 - Animations and transitions: `views/animations/` (`AnimationRules`, `Curves`, `SideAnimator`, `ValueInterpolation`,
-  `FadeThrough`, `SystemTransition`); `views/element/` (`ElementTransitions`, `TransitionLayer`, `TargetsWait`,
-  `animators/`); `options/StackAnimationOptions.kt`, `ViewAnimationOptions.kt`.
+  `FadeThrough`, `SystemTransition`, `AnimationLayer`: the hardware layer of a fade); `views/element/`
+  (`ElementTransitions`, `TransitionLayer`, `TargetsWait`, `animators/`); `options/StackAnimationOptions.kt`,
+  `ViewAnimationOptions.kt`.
 - System bars: `system/SystemUiOwner.kt`, `SystemUiLayers.kt`, `SystemUiRules.kt`, `SystemUiWindow.kt`,
   `AppDirection.kt`; `viewcontrollers/parent/ContainerBackground.kt`.
 - Events and state: `react/events/AppearanceDispatcher.kt`, `ScreenAppearance.kt`, `EventEmitter.kt`,
@@ -111,21 +113,21 @@ top-level folder. Main thread only, unless a line says otherwise.
 - Error texts and answers: `react/ErrorTexts.kt` and `react/CommandContract.kt`, made by `scripts/contract.mjs` from
   `src/interfaces/contract/errors.json` and `commands.json`.
 - Links: `react/LaunchLink.kt`, `NavigationActivity.kt` (`onNewIntent`); `react/StartInfo.kt`.
-- Hinge and regions: `react/Hinge.kt`, `react/ScreenRegions.kt`, `react/ScreenInsets.kt`, `utils/WindowFolds.kt`.
+- Hinge and regions: `react/Hinge.kt`, `react/ScreenRegions.kt`, `react/ScreenEnvironment.kt`, `utils/WindowFolds.kt`.
 - Native screens: `nativescreen/NativeScreenContext.kt`, `NativeScreenCalls.kt`, `NativeScreenCreator.kt`;
   `viewcontrollers/externalcomponent/`.
 - Slots: `slots/SlotHost.kt`, `SlotView.kt`, `SlotScreenView.kt`, `SlotContainers.kt` (containers and slot views by
   slot id: a change goes straight to the views of its id, `SlotViews.kt`), `SlotViewManager.kt`.
 - Safe area: `safearea/SafeAreaView.kt`, `SafeAreaViewManager.kt`; `viewcontrollers/component/ScreenReadiness.kt`;
-  `react/ScreenInsets.kt`.
+  `react/ScreenEnvironment.kt`.
 - The C++ of `ANNSlot`, `ANNSafeAreaView`: `android/src/main/jni/CMakeLists.txt`, `ApexNavigationSpec.h`; sources in
   `ios/cpp/`.
 
 ## Threads
 
 - **JS thread.** The sync getters `getScreenInsets`, `getScreenRegions`, `getArrangementState`, `getHinge`,
-  `getStartInfo` read stores (`ConcurrentHashMap` in `ScreenInsets`, `ScreenRegions`, `ArrangementStates`; `@Volatile`
-  in `Hinge`). They never touch a node.
+  `getStartInfo` read stores (one `ConcurrentHashMap` of immutable records in `ScreenEnvironment`; `@Volatile` in
+  `Hinge`). They never touch a node.
 - **Module thread.** The `check` of every command with a promise: `LayoutReader` and, through it, `OptionsReader` (also
   for `setDefaultOptions`, `mergeOptions` and the options of `dismissModal`, in the runner's `prepare` step);
   `ReadableJson` for native-screen props. The registry of native screens is read under its lock. Images are not loaded

package/android/CORE.md

@@ -10,7 +10,7 @@ otherwise.
 ```
 JS ─ ANNTurboModule (codegen NativeANNTurboModuleSpec)
  │      sync getters answer on the JS thread from stores the main thread fills
- │      (ScreenInsets, ScreenRegions, ArrangementStates, Hinge, StartInfo)
+ │      (ScreenEnvironment, Hinge, StartInfo)
  ▼ module thread
 react/NavigationTurboModule      one override per method
  │  layout/LayoutReader ► options/OptionsReader     the whole layout read and checked, its options read
@@ -188,7 +188,7 @@ Each rule has one owner. Change the owner, not a caller; if a new feature needs
 - **Room for the bars.** A screen's room at the top and bottom is `ScreenFrame` with `ScreenSafeArea` and the
   `ParentController` room hooks (`getTopInset`, `keepsStatusBarRoomOf`, …). A screen in a pair forwards its room to
   the pair (`ScreenFrame.applyRoom`), and the pair's `getTopInset` uses the screens' rule (`ScreenFrame.topRoomOf`)
-  with the options it shows with. A view's place in the window for the safe area (the React root, the stack's header
+  with the options it shows with. The bottom edge is not padded by default (only `'bottom'` in the edges pads it); `roomPadding` still shrinks the view for an opaque navigation bar and the keyboard. A view's place in the window for the safe area (the React root, the stack's header
   bottom in `headerBottomOf`, the tabs' top in `tabsTopOf`) is `RestPlace`: from layout, without translations, a sheet
   at rest.
 - **A container's own move.** A container that moves children in or out of the window without a command (the split
@@ -209,9 +209,9 @@ Modules are the feature classes that plug into the core through its contract (th
   (`SlotHost`, `SlotView`, `SlotContainers`), safe area (`SafeAreaView`), native screens (`nativescreen/`), splash
   (`splash/`), animations (`FadeThrough`, `SystemTransition`, `TransitionTargets`, three element animators), utils
   (`MaterialTheme`, `NavigationLog`, `awaitBarComponents`, `whenDrawn`).
-- **Stores and singletons:** regions (`Hinge`, `ScreenInsets`, `ScreenRegions`, `WindowFolds`), pair state
-  (`ArrangementStates`), links (`LaunchLink`, `StartInfo`), events (`NavigationState`), commands
-  (`BackCallbackState`), stack (`PreparedFrame`).
+- **Stores and singletons:** a screen's environment (`ScreenEnvironment`: its insets and padding, its regions as
+  `ScreenRegions` measures them, its pair state), the window (`Hinge`, `WindowFolds`), links (`LaunchLink`,
+  `StartInfo`), events (`NavigationState`), commands (`BackCallbackState`), stack (`PreparedFrame`).
 
 How they plug in:
 
@@ -235,5 +235,8 @@ How they plug in:
 - **Core code in a module's folder:** `viewcontrollers/splitview/SplitViewPresenter.kt`, `slots/SlotScreenView.kt`,
   and in `views/animations/` and `views/element/` everything except the files named above.
 - **Stores** are written on the main thread by the core and read from any thread; they are cleared with their nodes and on
-  reload. Their events, and the search's, go through the emitter of the JavaScript the screen was made for
+  reload. A screen's environment is one immutable record per id in `ScreenEnvironment` (insets for JavaScript, padding,
+  regions, pair state), replaced at once; the screen's node clears it with one `remove` when it is destroyed, unless a
+  later node has its id; the padding listeners of its safe area views stay until the views stop. Their events, and
+  the search's, go through the emitter of the JavaScript the screen was made for
   (`EventEmitter.of(node.jsGeneration)`); the hinge keeps the `EventEmitter.current()` of the call that turned it on.

package/android/src/main/java/dev/apexnative/navigation/NavigationActivity.kt

@@ -35,6 +35,7 @@ import dev.apexnative.navigation.splash.SplashTheme
 import dev.apexnative.navigation.splash.SplashView
 import dev.apexnative.navigation.system.SystemUiWindow
 import dev.apexnative.navigation.utils.MaterialTheme
+import dev.apexnative.navigation.viewcontrollers.modal.SheetBack
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackCheck
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
@@ -72,23 +73,33 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
     // Enabled while back has something to do in the app (BackCallbackState); otherwise the system does its own back.
     // From Android 14, where the app hears the progress of the back gesture, a gesture that would pop a stack with the
     // default transition previews the pop as the system previews back between activities (`StackController
-    // .BackGesture`); JavaScript's listeners hear back first, so with them there is no preview.
+    // .BackGesture`), and one that would dismiss a sheet previews its hide as Material's sheets do (`SheetBack`), its
+    // release closing it as a drag down does; JavaScript's listeners hear back first, so with them there is no preview.
     private val backCallback = object : OnBackPressedCallback(false) {
         override fun handleOnBackStarted(backEvent: BackEventCompat) {
             backGesture = null
-            navigator?.let { backCheck?.atBack(it) }
+            sheetGesture = null
+            val navigator = navigator ?: return
+            backCheck?.atBack(navigator)
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE || BackCallbackState.hasJsListeners) return
-            val stack = navigator?.stackPoppedByBack() ?: return
-            backGesture = stack.startBackGesture(backEvent.swipeEdge == BackEventCompat.EDGE_LEFT, backEvent.touchY)
+            val stack = navigator.stackPoppedByBack()
+            if (stack != null) {
+                backGesture = stack.startBackGesture(backEvent.swipeEdge == BackEventCompat.EDGE_LEFT, backEvent.touchY)
+                return
+            }
+            sheetGesture = navigator.sheetDismissedByBack()?.startBackPreview(backEvent)
         }
 
         override fun handleOnBackProgressed(backEvent: BackEventCompat) {
             backGesture?.progress(backEvent.progress, backEvent.touchY)
+            sheetGesture?.progress(backEvent)
         }
 
         override fun handleOnBackCancelled() {
             backGesture?.cancel()
             backGesture = null
+            sheetGesture?.cancel()
+            sheetGesture = null
             navigator?.let(BackCallbackState::update)
         }
 
@@ -96,13 +107,33 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
             navigator?.let { backCheck?.atBack(it) }
             val gesture = backGesture
             backGesture = null
-            if (gesture?.commit() == true) BackCallbackState.update() else passBack()
+            val sheet = sheetGesture
+            sheetGesture = null
+            when {
+                gesture?.commit() == true -> BackCallbackState.update()
+                sheet != null && commitSheet(sheet) -> BackCallbackState.update()
+                else -> passBack()
+            }
         }
     }
 
     // The back gesture that previews a pop now; none.
     private var backGesture: StackController.BackGesture? = null
 
+    // The back gesture that previews a sheet's hide now; none.
+    private var sheetGesture: SheetBack.Gesture? = null
+
+    // A sheet's preview released: the sheet goes as the user's drag down closes it, and back doesn't go on (no
+    // `passBack`, which would dismiss it a second time). A command that changed what back does since the gesture
+    // started (a push in the sheet, a modal over it, a hold) leaves it to the usual back, the sheet back in place.
+    private fun commitSheet(gesture: SheetBack.Gesture): Boolean {
+        if (navigator?.sheetDismissedByBack() !== gesture.sheet) {
+            gesture.cancel()
+            return false
+        }
+        return gesture.commit()
+    }
+
     // Debug builds only: the check that what back does never changes without its trigger (BackCallbackState), sampled
     // before frames and at back events. It only logs; release builds have neither the check nor the listener.
     private val backCheck = if (BuildConfig.DEBUG) BackCallbackCheck() else null

package/android/src/main/java/dev/apexnative/navigation/options/BottomTabsOptions.kt

@@ -95,6 +95,7 @@ class BottomTabsAccessoryOptions {
 class BottomTabsOptions {
     @JvmField var visible: Bool = NullBool()
     @JvmField var animate: Bool = NullBool()
+    @JvmField var switchAnimation: Text = NullText()
     /** Selects a tab once; a whole number, truncated where it is read. */
     @JvmField var currentTabIndex: Fraction = NullFraction()
     /** Selects a tab once. */
@@ -124,18 +125,19 @@ class BottomTabsOptions {
     @JvmField var minimizeBehavior: Text = NullText()
     @JvmField var bottomAccessory = BottomTabsAccessoryOptions()
 
-    fun hasValue(): Boolean = visible.hasValue() || animate.hasValue() || currentTabIndex.hasValue() ||
-        currentTabId.hasValue() || testID.hasValue() || accessibilityLabel.hasValue() || moreTestID.hasValue() ||
-        drawBehind.hasValue() || backgroundColor.hasValue() || tabsAttachMode.hasValue() || barStyle.hasValue() ||
-        layoutStyle.hasValue() || cornerRadius.hasValue() || bottomMargin.hasValue() || translucent.hasValue() ||
-        hideShadow.hasValue() || titleDisplayMode.hasValue() || elevation.hasValue() || hideOnScroll.hasValue() ||
-        borderColor.hasValue() || borderWidth.hasValue() || shadow.hasValue() || customRow.hasValue() ||
-        sidebar.hasValue() || sidebarLayout.hasValue() || customizationId.hasValue() || minimizeBehavior.hasValue() ||
-        bottomAccessory.hasValue()
+    fun hasValue(): Boolean = visible.hasValue() || animate.hasValue() || switchAnimation.hasValue() ||
+        currentTabIndex.hasValue() || currentTabId.hasValue() || testID.hasValue() || accessibilityLabel.hasValue() ||
+        moreTestID.hasValue() || drawBehind.hasValue() || backgroundColor.hasValue() || tabsAttachMode.hasValue() ||
+        barStyle.hasValue() || layoutStyle.hasValue() || cornerRadius.hasValue() || bottomMargin.hasValue() ||
+        translucent.hasValue() || hideShadow.hasValue() || titleDisplayMode.hasValue() || elevation.hasValue() ||
+        hideOnScroll.hasValue() || borderColor.hasValue() || borderWidth.hasValue() || shadow.hasValue() ||
+        customRow.hasValue() || sidebar.hasValue() || sidebarLayout.hasValue() || customizationId.hasValue() ||
+        minimizeBehavior.hasValue() || bottomAccessory.hasValue()
 
     fun mergeWith(other: BottomTabsOptions) {
         if (other.visible.hasValue()) visible = other.visible
         if (other.animate.hasValue()) animate = other.animate
+        if (other.switchAnimation.hasValue()) switchAnimation = other.switchAnimation
         if (other.currentTabIndex.hasValue()) currentTabIndex = other.currentTabIndex
         if (other.currentTabId.hasValue()) currentTabId = other.currentTabId
         if (other.testID.hasValue()) testID = other.testID
@@ -167,6 +169,7 @@ class BottomTabsOptions {
     fun mergeWithDefault(defaults: BottomTabsOptions) {
         if (!visible.hasValue()) visible = defaults.visible
         if (!animate.hasValue()) animate = defaults.animate
+        if (!switchAnimation.hasValue()) switchAnimation = defaults.switchAnimation
         if (!currentTabIndex.hasValue()) currentTabIndex = defaults.currentTabIndex
         if (!currentTabId.hasValue()) currentTabId = defaults.currentTabId
         if (!testID.hasValue()) testID = defaults.testID
@@ -198,6 +201,7 @@ class BottomTabsOptions {
     fun copy() = BottomTabsOptions().also { it.mergeWith(this) }
 
     companion object {
+        private val SWITCH_ANIMATIONS = setOf("platform", "none")
         private val TABS_ATTACH_MODES = setOf("together", "afterInitialTab", "onSwitchToTab")
         private val BAR_STYLES = setOf("default", "black")
         private val LAYOUT_STYLES = setOf("stretch", "compact")
@@ -212,6 +216,7 @@ class BottomTabsOptions {
             if (map == null) return options
             options.visible = BoolParser.parse(map, "visible")
             options.animate = BoolParser.parse(map, "animate")
+            options.switchAnimation = TextParser.parse(map, "switchAnimation", SWITCH_ANIMATIONS)
             options.currentTabIndex = FractionParser.parse(map, "currentTabIndex")
             options.currentTabId = TextParser.parse(map, "currentTabId")
             options.testID = TextParser.parse(map, "testID")

package/android/src/main/java/dev/apexnative/navigation/react/NavigationTurboModule.kt

@@ -236,11 +236,11 @@ class NavigationTurboModule(reactContext: ReactApplicationContext) : NativeANNTu
         check = {},
     ) { _, answer -> navigator().stackCommands.setColumnShown(componentId, column, shown, answer) }
 
-    override fun getArrangementState(componentId: String): WritableMap = ArrangementStates.get(componentId)
+    override fun getArrangementState(componentId: String): WritableMap = ScreenEnvironment.getArrangementState(componentId)
 
-    override fun getScreenInsets(componentId: String): WritableMap = ScreenInsets.get(componentId)
+    override fun getScreenInsets(componentId: String): WritableMap = ScreenEnvironment.getScreenInsets(componentId)
 
-    override fun getScreenRegions(componentId: String): WritableMap = ScreenRegions.get(componentId)
+    override fun getScreenRegions(componentId: String): WritableMap = ScreenEnvironment.getScreenRegions(componentId)
 
     // With the activity the user sees, if there is one; the hinge remembers it and goes on with the next activity
     // (`Hinge.attach`).

package/android/src/main/java/dev/apexnative/navigation/react/ReloadCoordinator.kt

@@ -82,8 +82,6 @@ internal object ReloadCoordinator {
         UiThread.runOnMain {
             launches.contextReady(context)
             NativeScreenCalls.failAll { name, componentId -> ErrorTexts.nativeCallReloaded(name, componentId) }
-            // Scroll listeners that found no event dispatcher listen now.
-            ScrollEvents.dispatcherReady()
             Navigators.all().filter { it.isNavigationResumed }.forEach(::launchIfDue)
         }
     }

package/android/src/main/java/dev/apexnative/navigation/react/ScreenEnvironment.kt

@@ -0,0 +1,177 @@
+package dev.apexnative.navigation.react
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import dev.apexnative.navigation.react.events.EventContract
+import dev.apexnative.navigation.react.events.EventEmitter
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * What JavaScript knows of each screen's place, by the screen's id, in one record: its safe area (the insets JavaScript
+ * gets and the padding of its safe area view, `useSafeAreaInsets`), its reserved regions (`useReservedRegions`) and,
+ * in a pair, its arrangement (`useArrangement`). The core measures them (`ScreenSafeArea`, [ScreenRegions], the pair's
+ * plan) on the main thread and keeps them here; JavaScript reads them from its own thread for a screen's first render
+ * and gets every change as an event. The record is immutable and replaced at once, so a reader on another thread sees
+ * one whole record. When the screen goes, [remove] clears all of it. As on iOS (`ANNScreenEnvironment`).
+ */
+internal object ScreenEnvironment {
+    /** How much covers each edge of a screen's content, in dp. */
+    data class Insets(val top: Double, val right: Double, val bottom: Double, val left: Double)
+
+    /** A reserved region, in dp from the top left of the screen's content. */
+    data class Region(val x: Double, val y: Double, val width: Double, val height: Double)
+
+    /** Where a screen divides (`division`) and where hardware covers it (`occlusion`). */
+    data class Regions(val division: List<Region>, val occlusion: List<Region>) {
+        val isEmpty: Boolean get() = division.isEmpty() && occlusion.isEmpty()
+    }
+
+    /** Which screen of its pair a screen is, how the pair lies, whether it lies over the other one and is hidden. */
+    data class Arrangement(val placement: String, val layout: String, val front: Boolean, val hidden: Boolean)
+
+    /** Where the changes JavaScript hears go: the events of the screen's JavaScript, or a test's record. */
+    interface Changes {
+        fun insetsChanged(screenId: String, insets: Insets)
+
+        fun regionsChanged(screenId: String, regions: Regions)
+
+        fun arrangementChanged(screenId: String, arrangement: Arrangement)
+    }
+
+    // One screen's record; null for a fact not known yet (not laid out, outside a pair).
+    private data class Record(
+        val insets: Insets? = null,
+        val padding: Insets? = null,
+        val regions: Regions? = null,
+        val arrangement: Arrangement? = null,
+    )
+
+    private val NO_REGIONS = Regions(emptyList(), emptyList())
+    private val records = ConcurrentHashMap<String, Record>()
+    // Main thread only.
+    private val paddingListeners = HashMap<String, MutableSet<() -> Unit>>()
+
+    /**
+     * Keeps the screen's [insets] for JavaScript (what still covers its content) and the [padding] of its safe area
+     * view. Calls the screen's padding listeners when the padding changed, then tells JavaScript when the insets did.
+     * Main thread only.
+     */
+    fun setInsets(screenId: String, insets: Insets, padding: Insets, changes: Changes) {
+        val before = update(screenId) { it.copy(insets = insets, padding = padding) }
+        if (before?.padding != padding) paddingListeners[screenId]?.toList()?.forEach { it() }
+        if (before?.insets != insets) changes.insetsChanged(screenId, insets)
+    }
+
+    /**
+     * Keeps the screen's [regions], and tells JavaScript when they changed; none at first is what JavaScript reads
+     * before the first layout, so it isn't told. Main thread only.
+     */
+    fun setRegions(screenId: String, regions: Regions, changes: Changes) {
+        val before = update(screenId) { it.copy(regions = regions) }?.regions
+        if (before == regions || (before == null && regions.isEmpty)) return
+        changes.regionsChanged(screenId, regions)
+    }
+
+    /** Keeps the screen's [arrangement], and tells JavaScript when it changed and [notify] holds. Main thread only. */
+    fun setArrangement(screenId: String, arrangement: Arrangement, notify: Boolean, changes: Changes) {
+        val before = update(screenId) { it.copy(arrangement = arrangement) }?.arrangement
+        if (before == arrangement || !notify) return
+        changes.arrangementChanged(screenId, arrangement)
+    }
+
+    /** The padding of the screen's safe area view; none before the screen was laid out. Any thread. */
+    fun padding(screenId: String): Insets? = records[screenId]?.padding
+
+    /** The insets JavaScript gets; none before the screen was laid out. Any thread. */
+    fun insets(screenId: String): Insets? = records[screenId]?.insets
+
+    /** The screen's reserved regions; none before its first layout. Any thread. */
+    fun regions(screenId: String): Regions? = records[screenId]?.regions
+
+    /** The screen's arrangement; none outside a pair. Any thread. */
+    fun arrangement(screenId: String): Arrangement? = records[screenId]?.arrangement
+
+    /**
+     * Calls `listener` when the padding of the screen changes; returns the function that stops it. Main thread only.
+     */
+    fun listenToPadding(screenId: String, listener: () -> Unit): () -> Unit {
+        paddingListeners.getOrPut(screenId) { LinkedHashSet() }.add(listener)
+        return {
+            paddingListeners[screenId]?.let {
+                it.remove(listener)
+                if (it.isEmpty()) paddingListeners.remove(screenId)
+            }
+        }
+    }
+
+    /**
+     * Forgets everything kept for the screen. Its padding listeners stay: a live safe area view keeps listening while
+     * it keeps the id, and stops itself.
+     */
+    fun remove(screenId: String) {
+        records.remove(screenId)
+    }
+
+    /** `getScreenInsets`: `{ top, right, bottom, left }`, empty before the screen was laid out. Any thread. */
+    fun getScreenInsets(screenId: String): WritableMap = insets(screenId)?.let(::toMap) ?: Arguments.createMap()
+
+    /** `getScreenRegions`: `{ division, occlusion }`, empty lists before the first layout. Any thread. */
+    fun getScreenRegions(screenId: String): WritableMap = toMap(regions(screenId) ?: NO_REGIONS)
+
+    /** `getArrangementState`: `{ placement, layout, front, hidden }`, empty outside a pair. Any thread. */
+    fun getArrangementState(screenId: String): WritableMap =
+        arrangement(screenId)?.let(::toMap) ?: Arguments.createMap()
+
+    /** The changes as events through [emitter], the one of the JavaScript the screen was made for. */
+    fun changesOf(emitter: EventEmitter): Changes = object : Changes {
+        override fun insetsChanged(screenId: String, insets: Insets) =
+            emitter.emitScreenInsetsChanged(screenId, toMap(insets))
+
+        override fun regionsChanged(screenId: String, regions: Regions) =
+            emitter.emitScreenRegionsChanged(screenId, toMap(regions))
+
+        override fun arrangementChanged(screenId: String, arrangement: Arrangement) =
+            emitter.emitArrangementChanged(screenId, toMap(arrangement))
+    }
+
+    // Replaces the screen's record at once with [change] of it; returns the record before, null for a new screen.
+    private fun update(screenId: String, change: (Record) -> Record): Record? {
+        var before: Record? = null
+        records.compute(screenId) { _, old ->
+            before = old
+            change(old ?: Record())
+        }
+        return before
+    }
+
+    private fun toMap(value: Insets): WritableMap = Arguments.createMap().apply {
+        putDouble(EventContract.ScreenInsetsChanged.TOP, value.top)
+        putDouble(EventContract.ScreenInsetsChanged.RIGHT, value.right)
+        putDouble(EventContract.ScreenInsetsChanged.BOTTOM, value.bottom)
+        putDouble(EventContract.ScreenInsetsChanged.LEFT, value.left)
+    }
+
+    private fun toMap(value: Regions): WritableMap = Arguments.createMap().apply {
+        putArray(EventContract.ScreenRegionsChanged.DIVISION, toArray(value.division))
+        putArray(EventContract.ScreenRegionsChanged.OCCLUSION, toArray(value.occlusion))
+    }
+
+    private fun toArray(regions: List<Region>): WritableArray = Arguments.createArray().apply {
+        for (region in regions) {
+            pushMap(Arguments.createMap().apply {
+                putDouble(EventContract.ScreenRegionRect.X, region.x)
+                putDouble(EventContract.ScreenRegionRect.Y, region.y)
+                putDouble(EventContract.ScreenRegionRect.WIDTH, region.width)
+                putDouble(EventContract.ScreenRegionRect.HEIGHT, region.height)
+            })
+        }
+    }
+
+    private fun toMap(value: Arrangement): WritableMap = Arguments.createMap().apply {
+        putString(EventContract.ArrangementChanged.PLACEMENT, value.placement)
+        putString(EventContract.ArrangementChanged.LAYOUT, value.layout)
+        putBoolean(EventContract.ArrangementChanged.FRONT, value.front)
+        putBoolean(EventContract.ArrangementChanged.HIDDEN, value.hidden)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/react/ScreenRegions.kt

@@ -3,36 +3,25 @@ package dev.apexnative.navigation.react
 import android.app.Activity
 import android.graphics.Rect
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import dev.apexnative.navigation.react.events.EventContract
+import dev.apexnative.navigation.react.ScreenEnvironment.Region
+import dev.apexnative.navigation.react.ScreenEnvironment.Regions
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.WindowFolds
-import java.util.concurrent.ConcurrentHashMap
 
 /**
- * The reserved regions of each screen (`useReservedRegions`), in dp from the top left of its content: where it divides
- * (a fold the window is divided at, `division`) and where hardware covers it (a fold that hides what is under it, the
- * camera cutout: `occlusion`). Only those on the screen, cut to it: a fold at the edge of a screen of a pair is not on
- * it. Measured on the main thread as each screen lays out, and again after a change of the window's folds (which lays
- * the window out); JavaScript reads them from its own thread for a screen's first render, and gets every change as
- * `ANN.ScreenRegionsChanged`.
+ * Measures the reserved regions of each screen (`useReservedRegions`), in dp from the top left of its content: where
+ * it divides (a fold the window is divided at, `division`) and where hardware covers it (a fold that hides what is
+ * under it, the camera cutout: `occlusion`). Only those on the screen, cut to it: a fold at the edge of a screen of a
+ * pair is not on it. Measured on the main thread as each screen lays out, and again after a change of the window's
+ * folds (which lays the window out); [ScreenEnvironment] keeps them, answers JavaScript's reads and tells it of every
+ * change as `ANN.ScreenRegionsChanged`.
  */
 internal object ScreenRegions {
-    data class Region(val x: Double, val y: Double, val width: Double, val height: Double)
-
-    data class Regions(val division: List<Region>, val occlusion: List<Region>) {
-        val isEmpty: Boolean get() = division.isEmpty() && occlusion.isEmpty()
-    }
-
-    private val NONE = Regions(emptyList(), emptyList())
-    private val regions = ConcurrentHashMap<String, Regions>()
-
     /**
      * Measures the regions of the screen whose content the layout puts at [content] in the window (pixels), with the
-     * window's [insets] (the camera cutout), and tells JavaScript when they changed, through [emitter], the one of the
-     * JavaScript the screen was made for: silent once it went. Main thread only.
+     * window's [insets] (the camera cutout), and keeps them in [ScreenEnvironment], which tells JavaScript when they
+     * changed through [emitter], the one of the JavaScript the screen was made for: silent once it went. Main thread
+     * only.
      */
     fun update(
         activity: Activity,
@@ -49,17 +38,7 @@ internal object ScreenRegions {
             occlusion = (folds.filter { it.occludes }.map { it.bounds } + cutouts)
                 .mapNotNull { onScreen(it, content, density) },
         )
-        val previous = regions.put(screenId, value)
-        // None at first is what JavaScript reads before the first layout.
-        if (previous == value || (previous == null && value.isEmpty)) return
-        emitter.emitScreenRegionsChanged(screenId, toMap(value))
-    }
-
-    /** `{ division, occlusion }`, empty lists for an unknown screen and before its first layout. Any thread. */
-    fun get(screenId: String): WritableMap = toMap(regions[screenId] ?: NONE)
-
-    fun remove(screenId: String) {
-        regions.remove(screenId)
+        ScreenEnvironment.setRegions(screenId, value, ScreenEnvironment.changesOf(emitter))
     }
 
     // The part of [bounds] (window pixels) on the screen, in dp from its top left; null off it. A fold without width
@@ -74,20 +53,4 @@ internal object ScreenRegions {
             height = part.height() / density.toDouble(),
         )
     }
-
-    private fun toMap(value: Regions): WritableMap = Arguments.createMap().apply {
-        putArray(EventContract.ScreenRegionsChanged.DIVISION, toArray(value.division))
-        putArray(EventContract.ScreenRegionsChanged.OCCLUSION, toArray(value.occlusion))
-    }
-
-    private fun toArray(regions: List<Region>): WritableArray = Arguments.createArray().apply {
-        for (region in regions) {
-            pushMap(Arguments.createMap().apply {
-                putDouble(EventContract.ScreenRegionRect.X, region.x)
-                putDouble(EventContract.ScreenRegionRect.Y, region.y)
-                putDouble(EventContract.ScreenRegionRect.WIDTH, region.width)
-                putDouble(EventContract.ScreenRegionRect.HEIGHT, region.height)
-            })
-        }
-    }
 }