@apexnative/navigation 1.0.0-alpha.0 → 1.0.0-alpha.10

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

@@ -3,37 +3,33 @@ package dev.apexnative.navigation.react
 import android.app.Activity
 import android.graphics.Rect
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.ReactApplication
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
+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. 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, screenId: String, content: Rect, insets: WindowInsetsCompat?) {
+    fun update(
+        activity: Activity,
+        screenId: String,
+        content: Rect,
+        insets: WindowInsetsCompat?,
+        emitter: EventEmitter,
+    ) {
         val folds = WindowFolds.of(activity)?.folds.orEmpty()
         val cutouts = insets?.displayCutout?.boundingRects.orEmpty()
         val density = activity.resources.displayMetrics.density
@@ -42,18 +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
-        val reactContext = (activity.application as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).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
@@ -68,20 +53,4 @@ internal object ScreenRegions {
             height = part.height() / density.toDouble(),
         )
     }
-
-    private fun toMap(value: Regions): WritableMap = Arguments.createMap().apply {
-        putArray("division", toArray(value.division))
-        putArray("occlusion", toArray(value.occlusion))
-    }
-
-    private fun toArray(regions: List<Region>): WritableArray = Arguments.createArray().apply {
-        for (region in regions) {
-            pushMap(Arguments.createMap().apply {
-                putDouble("x", region.x)
-                putDouble("y", region.y)
-                putDouble("width", region.width)
-                putDouble("height", region.height)
-            })
-        }
-    }
 }

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

@@ -1,25 +1,17 @@
 package dev.apexnative.navigation.react
 
-import android.content.Context
-import android.util.Log
-import com.facebook.react.ReactApplication
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.Event
-import com.facebook.react.uimanager.events.EventDispatcherListener
-import com.facebook.react.views.scroll.ScrollEvent
+import android.view.ViewGroup
+import android.widget.HorizontalScrollView
+import com.facebook.react.views.scroll.ReactScrollViewHelper
 import com.facebook.react.views.scroll.ScrollEventType
-import dev.apexnative.navigation.utils.NavigationLog
-import dev.apexnative.navigation.utils.UiThread
-import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
-import java.lang.reflect.Field
-import java.util.Collections
-import java.util.WeakHashMap
 
 /**
- * The scroll events of React Native's lists, as the screens' scroll listeners hear them: from the event dispatcher of
- * the running React Native, every list of the app. React Native keeps the offset, the speed and the kind of a scroll
- * event in private fields: they are looked up once, with their types; if React Native renames them, one warning goes to
- * the log and the screens hear no scroll, with no error at each event.
+ * The scroll events of React Native's scroll views, as the screens' scroll listeners hear them: through React Native's
+ * public scroll listener ([ReactScrollViewHelper.addScrollListener]), which every `ReactScrollView`,
+ * `ReactHorizontalScrollView` and `ReactNestedScrollView` of the process calls on the main thread just before it
+ * dispatches the same event to JavaScript, after the same throttle. One listener serves every screen and every React
+ * context; it is added while a screen listens and removed when the last one stops. Horizontal scroll views are left
+ * out: a pager or a carousel doesn't move the bars. Main thread only.
  */
 internal object ScrollEvents {
     /** What a scroll event is. */
@@ -28,133 +20,62 @@ internal object ScrollEvents {
     /** One scroll event: the list's tag (its view's id), its kind, its vertical offset and speed, in pixels. */
     class Reading(val viewTag: Int, val kind: Kind, val offsetY: Float, val velocityY: Float)
 
-    private class Fields(val type: Field, val offsetY: Field, val velocityY: Field)
+    // One screen's listening: its own object, so that a stop takes away that listening and no other.
+    private class Listening(val handler: (Reading) -> Unit)
 
-    private var fields: Fields? = null
-    private var lookedUp = false
+    // The screens' listenings, in the order they came.
+    private val listenings = mutableListOf<Listening>()
 
-    // The screens' listeners that found no event dispatcher, held weakly until React Native has one. Main thread.
-    private val waiting: MutableSet<ScrollEventListener> = Collections.newSetFromMap(WeakHashMap())
+    // React Native holds its scroll listeners weakly: this object keeps the one it added for as long as it is added.
+    private val listener = object : ReactScrollViewHelper.ScrollListener {
+        override fun onScroll(
+            scrollView: ViewGroup?,
+            scrollEventType: ScrollEventType?,
+            xVelocity: Float,
+            yVelocity: Float,
+        ) = hear(scrollView, scrollEventType, yVelocity)
 
-    /** [listener] found no event dispatcher: it is asked to listen again once React Native has one. */
-    fun waitForDispatcher(listener: ScrollEventListener) {
-        waiting += listener
-    }
-
-    /** A React context is ready (`ReloadCoordinator`): the listeners waiting for an event dispatcher listen now. */
-    fun dispatcherReady() {
-        val listeners = waiting.toList()
-        waiting.clear()
-        listeners.forEach(ScrollEventListener::attachIfNeeded)
+        override fun onLayout(scrollView: ViewGroup?) = Unit
     }
 
     /**
-     * Calls [handler] on the main thread with each scroll event of the app's React Native, until the function returned
-     * is called. None when React Native has no event dispatcher now (around a reload, the caller asks again later) or
-     * its scroll events can't be read.
+     * Calls [handler] with each scroll event of a vertical scroll view of the app, until the function returned is
+     * called.
      */
-    fun listen(context: Context, handler: (Reading) -> Unit): (() -> Unit)? {
-        if (fields() == null) return null
-        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext
-            ?: return null
-        val dispatcher = try {
-            UIManagerHelper.getEventDispatcher(reactContext)
-        } catch (e: RuntimeException) {
-            null
-        } ?: return null
-        val listener = EventDispatcherListener { event ->
-            // The event goes back to its pool after the dispatch: it is read now, on the thread that dispatches.
-            val reading = read(event) ?: return@EventDispatcherListener
-            if (UiThread.isMainThread()) handler(reading) else UiThread.post { handler(reading) }
+    fun listen(handler: (Reading) -> Unit): () -> Unit {
+        val listening = Listening(handler)
+        if (listenings.isEmpty()) ReactScrollViewHelper.addScrollListener(listener)
+        listenings += listening
+        return {
+            // By identity: the second call of a stop finds nothing to take away.
+            if (listenings.removeAll { it === listening } && listenings.isEmpty()) {
+                ReactScrollViewHelper.removeScrollListener(listener)
+            }
         }
-        dispatcher.addListener(listener)
-        return { dispatcher.removeListener(listener) }
     }
 
-    private fun read(event: Event<*>): Reading? {
-        if (event !is ScrollEvent) return null
-        val fields = fields() ?: return null
-        return try {
-            val type = fields.type.get(event) as? ScrollEventType ?: return null
-            val offsetY = readFloat(fields.offsetY, event) ?: return null
-            val velocityY = readFloat(fields.velocityY, event) ?: return null
-            Reading(event.viewTag, kindOf(type), offsetY, velocityY)
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: IllegalArgumentException) {
-            null
-        }
+    /** One call of React Native's listener: the handlers listening now hear its reading, if it has one. */
+    fun hear(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float) {
+        val reading = read(scrollView, type, velocityY) ?: return
+        listenings.toList().forEach { it.handler(reading) }
     }
 
-    private fun kindOf(type: ScrollEventType): Kind = when (type) {
+    /**
+     * The reading of one call of React Native's listener: none for a horizontal scroll view, or when React Native gives
+     * no view or no kind. The offset is the view's `scrollY` and the speed React Native's own, in pixels, as the event
+     * sent to JavaScript carries them before it converts them to dp.
+     */
+    fun read(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float): Reading? {
+        if (scrollView == null || type == null || scrollView is HorizontalScrollView) return null
+        return Reading(scrollView.id, kindOf(type), scrollView.scrollY.toFloat(), velocityY)
+    }
+
+    /** The kind of a reading for React Native's [type]. */
+    fun kindOf(type: ScrollEventType): Kind = when (type) {
         ScrollEventType.BEGIN_DRAG -> Kind.BeginDrag
         ScrollEventType.END_DRAG -> Kind.EndDrag
         ScrollEventType.SCROLL -> Kind.Scroll
         ScrollEventType.MOMENTUM_BEGIN -> Kind.MomentumBegin
         ScrollEventType.MOMENTUM_END -> Kind.MomentumEnd
     }
-
-    @Synchronized
-    private fun fields(): Fields? {
-        if (lookedUp) return fields
-        lookedUp = true
-        fields = try {
-            val owner = ScrollEvent::class.java
-            val type = declaredField(owner, TYPE_NAMES) { ScrollEventType::class.java.isAssignableFrom(it) }
-            val offsetY = declaredField(owner, OFFSET_NAMES, ::isNumeric)
-            val velocityY = declaredField(owner, VELOCITY_NAMES, ::isNumeric)
-            if (type != null && offsetY != null && velocityY != null) Fields(type, offsetY, velocityY) else null
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: SecurityException) {
-            null
-        }
-        if (fields == null) {
-            Log.w(
-                NavigationLog.TAG,
-                "[ApexNavigation] React Native's scroll events changed: hideOnScroll and the large title " +
-                    "don't follow the scroll",
-            )
-        }
-        return fields
-    }
-
-    // The names of the fields: React Native 0.87 first, then the earlier ones with the `m` prefix.
-    private val TYPE_NAMES = listOf("scrollEventType", "mScrollEventType")
-    private val OFFSET_NAMES = listOf("scrollY", "mScrollY")
-    private val VELOCITY_NAMES = listOf("yVelocity", "mYVelocity")
-
-    /**
-     * The first of the fields [names] that [owner] declares with a type [accepted] takes, made readable; none when no
-     * name fits. React Native renamed them and changed their types between versions.
-     */
-    fun declaredField(owner: Class<*>, names: List<String>, accepted: (Class<*>) -> Boolean): Field? {
-        for (name in names) {
-            val field = try {
-                owner.getDeclaredField(name)
-            } catch (e: NoSuchFieldException) {
-                continue
-            }
-            if (!accepted(field.type)) continue
-            field.isAccessible = true
-            return field
-        }
-        return null
-    }
-
-    /** A number of any kind: a primitive one (`int`, `float`, `double`, …) or a boxed one. */
-    fun isNumeric(type: Class<*>): Boolean =
-        type in PRIMITIVE_NUMBERS || Number::class.java.isAssignableFrom(type)
-
-    /** [field] of [target] as a float, whatever numeric type it has; none when it holds no number. */
-    fun readFloat(field: Field, target: Any): Float? = (field.get(target) as? Number)?.toFloat()
-
-    private val PRIMITIVE_NUMBERS = setOf<Class<*>?>(
-        Byte::class.javaPrimitiveType,
-        Short::class.javaPrimitiveType,
-        Int::class.javaPrimitiveType,
-        Long::class.javaPrimitiveType,
-        Float::class.javaPrimitiveType,
-        Double::class.javaPrimitiveType,
-    )
 }

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

@@ -90,7 +90,7 @@ internal object AppearanceDispatcher {
         val appearanceRecord: ScreenAppearance?
     }
 
-    /** The navigation state (`NavigationStateReporter`): one update in this pass of the main loop, or one now. */
+    /** The navigation state ([NavigationState]): one update in this pass of the main loop, or one now. */
     interface StateUpdates {
         /**
          * Asks for one update in this pass of the main loop: the calls of one pass make one, after a DidAppear or a
@@ -98,7 +98,10 @@ internal object AppearanceDispatcher {
          */
         fun setNeedsUpdate()
 
-        /** Computes the state now and sends it when it changed: before an answer, at the end of a transition. */
+        /**
+         * Computes the state now and sends it when it changed: a command's answer, once
+         * (`CommandAnswer.reportStateNow`), the end of a user's transition, a tab chosen from code.
+         */
         fun updateNow()
 
         /**
@@ -157,33 +160,6 @@ internal object AppearanceDispatcher {
             EventEmitter.current().emitSheetDetentChanged(componentId, detent)
     }
 
-    /** The state of `NavigationStateReporter`, sent through the JavaScript that runs now, when it can be. */
-    object ReporterState : StateUpdates {
-        private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-        // The one posted update of a pass of the main loop, which checks the hold when it runs.
-        private val held = StateHold(
-            post = { task -> handler.post(task) },
-            generation = { ReloadCoordinator.generation },
-        ) {
-            val emitter = EventEmitter.current()
-            if (emitter.canSend) NavigationStateReporter.updateNow(emitter)
-        }
-
-        override fun setNeedsUpdate() {
-            if (EventEmitter.current().canSend) held.setNeedsUpdate()
-        }
-
-        override fun hold() = held.hold()
-
-        override fun release() = held.release()
-
-        override fun updateNow() {
-            val emitter = EventEmitter.current()
-            if (emitter.canSend) NavigationStateReporter.updateNow(emitter)
-        }
-    }
-
     /** The main thread's loop. */
     object MainScheduler : Scheduler {
         private val handler by lazy { Handler(Looper.getMainLooper()) }
@@ -198,8 +174,8 @@ internal object AppearanceDispatcher {
     /** Where the events go: [EmitterSender]; the tests put a journal here. */
     var sender: Sender = EmitterSender
 
-    /** The navigation state the sent appearance events and transitions update: [ReporterState]; a journal in tests. */
-    var state: StateUpdates = ReporterState
+    /** The navigation state the appearance events and transitions update: [NavigationState]; a journal in tests. */
+    var state: StateUpdates = NavigationState
 
     /** The clock of the hold limit: [MainScheduler]; the tests put a clock that moves when they say. */
     var scheduler: Scheduler = MainScheduler
@@ -210,43 +186,18 @@ internal object AppearanceDispatcher {
     // A transition whose caller sends the state itself ends: the DidDisappears it sends ask for no update.
     private var holdsState = false
 
-    // A side menu's drawer jumps open: the appearances that start in it send no WillAppear.
-    private var skipsWillAppear = false
-
     // The native screens that told JavaScript they went: once per node.
     private val released: MutableSet<ViewController<*>> = Collections.newSetFromMap(WeakHashMap())
 
     // Appearance of a record.
 
-    /**
-     * The record starts to appear: WillAppear, now when it is ready, else held. Only once per appearance; none inside
-     * [withoutWillAppear].
-     */
+    /** The record starts to appear: WillAppear, now when it is ready, else held. Only once per appearance. */
     fun willAppear(record: ScreenAppearance) {
         if (record.phase != Phase.Hidden) return
         record.phase = Phase.Appearing
-        if (skipsWillAppear) {
-            record.skippedWill = true
-            return
-        }
         if (record.isReady) send(record, Event.WillAppear) else hold(record, Event.WillAppear)
     }
 
-    /**
-     * Runs [block], in which the appearances that start send no WillAppear: their DidAppear is their first event, and
-     * their DidDisappear goes only once that DidAppear went. A side menu's drawer that opens without animation does so
-     * on Android; the screens' options and the components of their bars go as at any appearance.
-     */
-    fun withoutWillAppear(block: () -> Unit) {
-        val outer = skipsWillAppear
-        skipsWillAppear = true
-        try {
-            block()
-        } finally {
-            skipsWillAppear = outer
-        }
-    }
-
     /**
      * The record has appeared: DidAppear, after a WillAppear (asked now when it wasn't), now when nothing is held and
      * it is ready, else held behind what is held. Only once per appearance.
@@ -261,19 +212,12 @@ internal object AppearanceDispatcher {
     /**
      * The record has disappeared. Nothing when it didn't appear. When its WillAppear is still held, JavaScript never
      * heard it appear: what is held goes away and nothing is sent. Otherwise a held DidAppear goes away and
-     * DidDisappear is sent: a swipe that was cancelled gives WillAppear, then DidDisappear. An appearance without its
-     * WillAppear ([withoutWillAppear]) appeared once its DidAppear went.
+     * DidDisappear is sent: a swipe that was cancelled gives WillAppear, then DidDisappear.
      */
     fun didDisappear(record: ScreenAppearance) {
         if (record.phase == Phase.Hidden) return
-        val wasShown = record.phase == Phase.Shown
         record.phase = Phase.Hidden
-        val appeared = if (record.skippedWill) {
-            wasShown && Event.DidAppear !in record.held
-        } else {
-            Event.WillAppear !in record.held
-        }
-        record.skippedWill = false
+        val appeared = Event.WillAppear !in record.held
         record.held.clear()
         cancelLimit(record)
         // What waited for its DidAppear goes now: none will be sent for this appearance.
@@ -369,12 +313,15 @@ internal object AppearanceDispatcher {
     }
 
     /**
-     * A transition ended,: what went disappears ([hiding]), what stands appears ([showing], with its WillAppear first
+     * A transition ended: what went disappears ([hiding]), what stands appears ([showing], with its WillAppear first
      * where it wasn't asked), the navigation state goes when it changed, then [events] (the transition's own:
      * `ANN.ScreenPopped`, `ANN.ModalDismissed`, and what must follow them, like stopping the content of what went),
-     * then [answer] resolves with [value] (the promise, then `ANN.CommandCompleted`). A user's action has no answer. A
-     * state that fails is logged ([log]) and the transition goes on: [events] and the answer always come. Without
-     * [reportsState] the caller sends the state itself, later (a tab switch: after `ANN.BottomTabSelected`).
+     * then [answer] resolves with [value] (the promise, then `ANN.CommandCompleted`; no second state). The state is the
+     * answer's one state step (`CommandAnswer.reportStateNow`), which sends nothing for a JavaScript that went; a
+     * user's action has no answer, and a command answered before its transition ended had its state then: the state
+     * of the end goes all the same, unless its JavaScript went. A state that fails is logged and the transition goes
+     * on: [events] and the answer always come. Without [reportsState] the caller sends the state itself, later (a tab
+     * switch: after `ANN.BottomTabSelected`; a `setRoot` with layers: from its answer).
      */
     fun endTransition(
         hiding: List<ViewController<*>>,
@@ -392,18 +339,30 @@ internal object AppearanceDispatcher {
             holdsState = false
         }
         showing.forEach { it.onViewDidAppear() }
-        if (reportsState) reportState(answer?.commandName)
+        if (reportsState) {
+            // The state before the transition's events, once per answer: the answer's own step before its promise
+            // finds it sent. Without an answer to wait for, the dispatcher sends it; nothing for a JavaScript that
+            // went.
+            when {
+                answer == null -> reportState()
+                answer.isAnswered -> if (ReloadCoordinator.isCurrent(answer.generation)) reportState()
+                else -> answer.reportStateNow()
+            }
+        }
         events?.invoke()
         answer?.resolve(value)
     }
 
-    /** The navigation state now, when it changed; a failure is logged ([log]), nothing else stops for it. */
-    fun reportState(commandName: String? = null) {
+    /**
+     * The navigation state now, when it changed, without a command's answer (a command's goes through its answer,
+     * `CommandAnswer.reportStateNow`); a failure is logged ([log]), nothing else stops for it.
+     */
+    fun reportState() {
         try {
             state.updateNow()
         } catch (e: Throwable) {
             val reason = ErrorTexts.couldNot("report the navigation state", ErrorTexts.reasonOf(e))
-            log("[ApexNavigation] ${commandName ?: "transition"}: $reason")
+            log("[ApexNavigation] transition: $reason")
         }
     }
 
@@ -423,12 +382,14 @@ internal object AppearanceDispatcher {
 
     /**
      * [modal] went with [count] modals (EVT-ModalDismissed): `ANN.ModalDismissed` with the id and the name of the
-     * screen the modal shows, down its current children.
+     * screen the modal shows, down its current children ([modalScreen]); a modal that shows no screen gives its own id
+     * and no name.
      */
     fun modalDismissed(modal: ViewController<*>, count: Int) {
         if (!ReloadCoordinator.isCurrent(modal.jsGeneration)) return
-        val screen = visibleNode(modal)
-        sender.modalDismissed(screen.id, screen.currentComponentName.orEmpty(), count)
+        val named = modalScreen(modal)
+        val name = if (named is ParentController<*>) "" else named.currentComponentName.orEmpty()
+        sender.modalDismissed(named.id, name, count)
     }
 
     /**
@@ -481,7 +442,7 @@ internal object AppearanceDispatcher {
      * modal shows. Nothing for a JavaScript that went.
      */
     fun modalAttemptedToDismiss(modal: ViewController<*>) {
-        val screen = visibleNode(modal)
+        val screen = modalScreen(modal)
         if (ReloadCoordinator.isCurrent(screen.jsGeneration)) sender.modalAttemptedToDismiss(screen.id)
     }
 
@@ -490,18 +451,26 @@ internal object AppearanceDispatcher {
      * Nothing for a JavaScript that went.
      */
     fun sheetDetentChanged(modal: ViewController<*>, detent: Any) {
-        val screen = visibleNode(modal)
+        val screen = modalScreen(modal)
         if (ReloadCoordinator.isCurrent(screen.jsGeneration)) sender.sheetDetentChanged(screen.id, detent)
     }
 
     /**
      * The screen [node] shows: the node at the end of its current children (the one "visible screen" of the core): what
-     * `ANN.ModalDismissed`, `ANN.ModalAttemptedToDismiss`, `ANN.SheetDetentChanged` and back's
-     * `ANN.NavigationButtonPressed` of a modal name. A layout without a child answers itself.
+     * back's `ANN.NavigationButtonPressed` of a modal names, and, through [modalScreen], its `ANN.ModalDismissed`,
+     * `ANN.ModalAttemptedToDismiss` and `ANN.SheetDetentChanged`. A layout without a child answers itself.
      */
     fun visibleNode(node: ViewController<*>): ViewController<*> {
         var current = node
         while (current is ParentController<*>) current = current.currentChild ?: break
         return current
     }
+
+    /**
+     * The node the events of the modal [modal] (its root) name: its [visibleNode] when that is a screen; the root
+     * itself when the chain ends in a layout without a child, as on iOS. Asked again of what it gave, it gives the
+     * same.
+     */
+    fun modalScreen(modal: ViewController<*>): ViewController<*> =
+        visibleNode(modal).takeUnless { it is ParentController<*> } ?: modal
 }