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

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

@@ -1,69 +0,0 @@
-package dev.apexnative.navigation.react
-
-import android.content.Context
-import com.facebook.react.ReactApplication
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-import dev.apexnative.navigation.react.events.EventEmitter
-import java.util.concurrent.ConcurrentHashMap
-
-/**
- * The safe area of each screen, in dp: how much of its content the bars and the system cover on each side. The padding
- * is the part of it the screen's safe area view keeps its content out of: the insets on the edges the screen's options
- * give. JavaScript gets the rest, what still covers the content (0 on a padded edge): it reads it from its own thread
- * for a screen's first render, and gets every change as `ANN.ScreenInsetsChanged`.
- */
-object ScreenInsets {
-    data class Insets(val top: Double, val right: Double, val bottom: Double, val left: Double)
-
-    private val insets = ConcurrentHashMap<String, Insets>()
-    // Main thread only.
-    private val padding = HashMap<String, Insets>()
-    private val paddingListeners = HashMap<String, MutableSet<() -> Unit>>()
-
-    /** The padding of the screen's safe area view; none before the screen was laid out. */
-    fun padding(screenId: String): Insets? = padding[screenId]
-
-    /** Calls `listener` when the padding of the screen changes; returns the function that stops it. */
-    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)
-            }
-        }
-    }
-
-    /** Keeps the screen's insets and padding, and tells when they changed. */
-    fun update(context: Context, screenId: String, value: Insets, paddingValue: Insets) {
-        if (padding.put(screenId, paddingValue) != paddingValue) {
-            paddingListeners[screenId]?.toList()?.forEach { it() }
-        }
-        // JavaScript gets what still covers the content: the edges the safe area view keeps it off are 0.
-        val uncovered = Insets(
-            top = (value.top - paddingValue.top).coerceAtLeast(0.0),
-            right = (value.right - paddingValue.right).coerceAtLeast(0.0),
-            bottom = (value.bottom - paddingValue.bottom).coerceAtLeast(0.0),
-            left = (value.left - paddingValue.left).coerceAtLeast(0.0),
-        )
-        if (insets.put(screenId, uncovered) == uncovered) return
-        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).emitScreenInsetsChanged(screenId, toMap(uncovered))
-    }
-
-    /** `{ top, right, bottom, left }`, empty before the screen was laid out. Any thread. */
-    fun get(screenId: String): WritableMap = insets[screenId]?.let(::toMap) ?: Arguments.createMap()
-
-    fun remove(screenId: String) {
-        insets.remove(screenId)
-        padding.remove(screenId)
-    }
-
-    private fun toMap(value: Insets): WritableMap = Arguments.createMap().apply {
-        putDouble("top", value.top)
-        putDouble("right", value.right)
-        putDouble("bottom", value.bottom)
-        putDouble("left", value.left)
-    }
-}

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

@@ -1,62 +0,0 @@
-package dev.apexnative.navigation.react.events
-
-import android.os.Handler
-import android.os.Looper
-import dev.apexnative.navigation.viewcontrollers.bottomtabs.BottomTabsController
-import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
-import dev.apexnative.navigation.viewcontrollers.parent.ParentController
-import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
-
-/**
- * Tells JavaScript the screen the user sees and the selected tab when they change. Every change of the screen the
- * user sees comes with a screen appearing: a push, a pop, a modal, a tab, a menu. One update after the events of a
- * pass of the main loop, and one at once before a command resolves its promise; each sent only when the state changed.
- */
-object NavigationStateReporter {
-    internal data class State(val screenId: String?, val screenName: String?, val tab: Int?)
-
-    private val handler = Handler(Looper.getMainLooper())
-    private var state: State? = null
-    private var scheduled = false
-
-    /** The new JavaScript has no state yet: the next one goes to it whatever it is. */
-    fun reset() {
-        state = null
-    }
-
-    fun setNeedsUpdate(emitter: EventEmitter) {
-        if (scheduled) return
-        scheduled = true
-        handler.post {
-            scheduled = false
-            updateNow(emitter)
-        }
-    }
-
-    /**
-     * Sends the state at once when it differs from the last one sent. A command calls it right before it resolves its
-     * promise: the event and the resolution reach JavaScript in that order, so the state is new when the `await` of
-     * the command goes on. The update already scheduled then finds nothing new. Main thread only.
-     */
-    fun updateNow(emitter: EventEmitter) {
-        // The navigation of the activity the commands run in (`Navigators.current`).
-        val navigator = Navigators.current()?.navigator ?: return
-        val next = stateOf(navigator.visibleLayout)
-        if (next == state) return
-        state = next
-        emitter.emitNavigationStateChanged(next.screenId, next.screenName, next.tab)
-    }
-
-    // The top modal, or the root ([layout]), down to the screen the user sees; overlays don't count. The tab is the
-    // selected one of the nearest tabs the screen is in, the last met on the way down, in a modal too: the tabs
-    // `selectTab` acts on from it. None for a screen out of tabs.
-    internal fun stateOf(layout: ViewController<*>?): State {
-        var tab: Int? = null
-        var current = layout ?: return State(null, null, null)
-        while (current is ParentController<*>) {
-            if (current is BottomTabsController) tab = current.selectedIndex
-            current = current.currentChild ?: return State(null, null, null)
-        }
-        return State(current.id, current.currentComponentName, tab)
-    }
-}

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

@@ -1,62 +0,0 @@
-package dev.apexnative.navigation.react.events
-
-/**
- * The navigation state's posted update and its hold. [setNeedsUpdate] posts one update ([post]), coalesced: the asks of
- * one pass of the main loop make one, which runs [update] in a later pass. While a `setRoot` shows the modals and the
- * overlays of its layout the updates are held: an ask, or a posted update that runs while held (asked before the hold
- * was taken), only marks one as wanted, and the last release posts it. Released right before the answer, that update
- * finds nothing new: the state before the answer is sent at once, never held, and an identical state is never sent
- * twice. Every [hold] has one [release]; a release without a hold does nothing, so the count never goes below zero. An
- * update keeps the JavaScript it was asked for ([generation]): one asked by a JavaScript that went before it runs is
- * dropped; a newer ask of the new JavaScript still goes. Main thread only.
- */
-internal class StateHold(
-    private val post: (() -> Unit) -> Unit,
-    private val generation: () -> Int = { 0 },
-    private val update: () -> Unit,
-) {
-    /** The holds not released yet. */
-    var count = 0
-        private set
-
-    // An update was asked while held.
-    private var wanted = false
-    // An update is posted and hasn't run yet.
-    private var scheduled = false
-    // The JavaScript the last ask was for.
-    private var askedIn = 0
-
-    /** Asks for one update in a later pass of the main loop; while held, once the last hold is released. */
-    fun setNeedsUpdate() {
-        askedIn = generation()
-        if (count > 0) wanted = true else schedule()
-    }
-
-    /** The updates asked from now on, and those posted that run from now on, wait for as many [release]s. */
-    fun hold() {
-        count++
-    }
-
-    /** One hold ends; with the last, the update asked while held is posted now. */
-    fun release() {
-        if (count == 0) return
-        count--
-        if (count > 0 || !wanted) return
-        wanted = false
-        schedule()
-    }
-
-    private fun schedule() {
-        if (scheduled) return
-        scheduled = true
-        post {
-            scheduled = false
-            // A hold taken since it was posted: the update waits for the release. The JavaScript it was asked for
-            // went: nothing goes to the new one, which hears its first state after its own changes.
-            when {
-                count > 0 -> wanted = true
-                askedIn == generation() -> update()
-            }
-        }
-    }
-}

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

@@ -1,223 +0,0 @@
-package dev.apexnative.navigation.viewcontrollers.bottomtabs
-
-import android.app.Activity
-import android.app.Application
-import android.os.Bundle
-import android.view.View
-import android.view.ViewGroup
-import android.view.ViewTreeObserver
-import androidx.core.view.ViewCompat
-import androidx.core.view.WindowInsetsCompat
-import dev.apexnative.navigation.NavigationActivity
-import dev.apexnative.navigation.utils.UiUtils
-import dev.apexnative.navigation.viewcontrollers.modal.ModalContainer
-import dev.apexnative.navigation.views.bottomtabs.BottomTabsLayout
-import dev.apexnative.navigation.views.bottomtabs.CustomTabRow
-import java.util.WeakHashMap
-
-/**
- * Puts the custom rows of the tabs in their place, as it works now: an observer of every activity of the process that
- * touches only the navigation's activities; on each layout pass of such a window it finds the tabs with a row through
- * the view tree, and puts each row in the window's content right above the layer holding its tabs (after the rows
- * already there) — tabs in a modal: in the modal's own view, right above its root's view (or its sheet), so the row
- * moves with the modal and newer modals cover it —, over the bar as [CustomTabRowGeometry] says — applied only when it
- * changed, so UI tests reach idle. A row whose tabs left the window leaves it too, and comes back to its place as they
- * do. Before each frame the row takes its tabs' alpha (a root that waits under the old one is transparent) and the
- * motion of the bar's container, and stays out of accessibility and touches while they wait. Main thread only.
- */
-internal object CustomTabRowPlacer : Application.ActivityLifecycleCallbacks {
-    private var registered = false
-    // The listeners of each observed activity's window.
-    private val observed = WeakHashMap<Activity, Listeners>()
-    // The rows placed at the last layout pass of each activity, with their tabs.
-    private val rows = WeakHashMap<CustomTabRow, BottomTabsLayout>()
-
-    private class Listeners(
-        val observer: ViewTreeObserver,
-        val layout: ViewTreeObserver.OnGlobalLayoutListener,
-        val draw: ViewTreeObserver.OnPreDrawListener,
-    )
-
-    /** [activity] has tabs with a row: its window is observed from now on, and the process's later activities. */
-    fun track(activity: Activity) {
-        if (!registered) {
-            registered = true
-            activity.application?.registerActivityLifecycleCallbacks(this)
-        }
-        observe(activity)
-    }
-
-    /** The tabs of [row] go: the row leaves the window. */
-    fun forget(row: CustomTabRow) {
-        rows.remove(row)
-        (row.parent as? ViewGroup)?.removeView(row)
-    }
-
-    override fun onActivityResumed(activity: Activity) = observe(activity)
-
-    override fun onActivityDestroyed(activity: Activity) {
-        val listeners = observed.remove(activity) ?: return
-        if (!listeners.observer.isAlive) return
-        listeners.observer.removeOnGlobalLayoutListener(listeners.layout)
-        listeners.observer.removeOnPreDrawListener(listeners.draw)
-    }
-
-    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
-
-    override fun onActivityStarted(activity: Activity) = Unit
-
-    override fun onActivityPaused(activity: Activity) = Unit
-
-    override fun onActivityStopped(activity: Activity) = Unit
-
-    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
-
-    // Only the navigation's activities: another activity's views are never looked for.
-    private fun observe(activity: Activity) {
-        if (activity !is NavigationActivity || observed.containsKey(activity)) return
-        val decor = activity.window?.decorView ?: return
-        val observer = decor.viewTreeObserver
-        val layout = ViewTreeObserver.OnGlobalLayoutListener { place(activity) }
-        val draw = ViewTreeObserver.OnPreDrawListener {
-            follow(activity)
-            true
-        }
-        observer.addOnGlobalLayoutListener(layout)
-        observer.addOnPreDrawListener(draw)
-        observed[activity] = Listeners(observer, layout, draw)
-    }
-
-    private fun contentOf(activity: Activity): ViewGroup? =
-        activity.window?.decorView?.findViewById(android.R.id.content)
-
-    // Each layout pass: the tabs with a row in the content, and the rows in their places.
-    private fun place(activity: NavigationActivity) {
-        val content = contentOf(activity) ?: return
-        val found = ArrayList<BottomTabsLayout>()
-        collect(content, found)
-        val placed = found.mapNotNull { tabs -> tabs.row?.also { place(activity, content, tabs, it) } }.toSet()
-        // A row whose tabs left the window leaves it too.
-        rows.entries.filter { (row, tabs) -> row !in placed && tabs.context === activity }.forEach { (row, _) ->
-            (row.parent as? ViewGroup)?.removeView(row)
-        }
-    }
-
-    private fun collect(view: View, found: MutableList<BottomTabsLayout>) {
-        if (view is CustomTabRow) return
-        if (view is BottomTabsLayout && view.row != null) found += view
-        if (view is ViewGroup) for (index in 0 until view.childCount) collect(view.getChildAt(index), found)
-    }
-
-    private fun place(activity: NavigationActivity, content: ViewGroup, tabs: BottomTabsLayout, row: CustomTabRow) {
-        rows[row] = tabs
-        val (host, layer) = placeIn(content, tabs) ?: return
-        if (row.parent !== host) {
-            (row.parent as? ViewGroup)?.removeView(row)
-            // Margins of the host's own kind: the host converts them (a frame or a coordinator layout).
-            host.addView(row, indexAbove(host, layer, row), ViewGroup.MarginLayoutParams(0, 0))
-            row.place = null
-        } else if (host.indexOfChild(row) != indexAbove(host, layer, row)) {
-            val params = row.layoutParams
-            host.removeView(row)
-            host.addView(row, indexAbove(host, layer, row), params)
-        }
-        row.showWith(tabs.bar)
-        if (tabs.bar.visibility == View.GONE || tabs.bar.width == 0) return
-        val place = placeOf(activity, host, tabs, row)
-        if (!CustomTabRowGeometry.needsPlacing(row.place, place)) return
-        row.place = place
-        val params = row.layoutParams as? ViewGroup.MarginLayoutParams ?: return
-        params.width = place.right - place.left
-        params.height = place.bottom - place.top
-        params.leftMargin = place.left
-        params.topMargin = place.top
-        row.layoutParams = params
-    }
-
-    // Over the bar: its edges less the margins, its bottom, the height of the content and the margin below it, in the
-    // coordinates of the row's [host].
-    private fun placeOf(
-        activity: Activity,
-        host: ViewGroup,
-        tabs: BottomTabsLayout,
-        row: CustomTabRow,
-    ): CustomTabRowGeometry.Place {
-        val bar = IntArray(2).also(tabs.bar::getLocationInWindow)
-        val origin = IntArray(2).also(host::getLocationInWindow)
-        val options = row.options
-        val margin = UiUtils.dpToPixels(
-            activity,
-            options.horizontalMargin.get(CustomTabRowGeometry.HORIZONTAL_MARGIN_DP.toDouble()),
-        )
-        val height = options.height.get(null)?.let { UiUtils.dpToPixels(activity, it) }
-        val extra = UiUtils.dpToPixels(activity, CustomTabRowGeometry.EXTRA_HEIGHT_DP.toDouble())
-        // Where the bar rests: its container's motion (a ride, a slide, the hide on scroll) the row takes before each
-        // frame as its own translation.
-        val left = bar[0] - origin[0] - tabs.container.translationX.toInt()
-        val top = bar[1] - origin[1] - tabs.container.translationY.toInt()
-        // Never over the navigation bar's buttons: the bar is above them, and so is the row.
-        val navigationBar = if ((activity as? NavigationActivity)?.isEdgeToEdge == true) navigationBarOf(host) else 0
-        return CustomTabRowGeometry.place(
-            barLeft = left,
-            barRight = left + tabs.bar.width,
-            barBottom = minOf(top + tabs.bar.height, host.height - navigationBar),
-            margin = margin,
-            content = CustomTabRowGeometry.content(tabs.bar.height, height, extra),
-            bottomMargin = UiUtils.dpToPixels(activity, options.bottomMargin.get(0.0)),
-        )
-    }
-
-    // The navigation bar at the bottom of the window, through the compat insets on every version.
-    private fun navigationBarOf(view: View): Int =
-        ViewCompat.getRootWindowInsets(view)?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
-
-    // Where the row of [tabs] goes, and the child there it goes right above: tabs in a modal, the modal's own view and
-    // the view in it that holds them (its root's, or its sheet's container); else the content and the layer of the
-    // root or of the overlays. A sheet's drag moves it without a layout: the row doesn't follow a drag.
-    private fun placeIn(content: ViewGroup, tabs: View): Pair<ViewGroup, View>? {
-        var current: View = tabs
-        while (true) {
-            val parent = current.parent as? ViewGroup ?: return null
-            if (parent is ModalContainer || parent === content) return parent to current
-            current = parent
-        }
-    }
-
-    // Right above [layer], after the rows already there.
-    private fun indexAbove(host: ViewGroup, layer: View, row: CustomTabRow): Int {
-        var index = host.indexOfChild(layer) + 1
-        while (index < host.childCount) {
-            val child = host.getChildAt(index)
-            if (child !is CustomTabRow || child === row) break
-            index++
-        }
-        return index
-    }
-
-    // Before each frame: the row takes the alpha of its tabs up to the view it is in and the container's translation,
-    // and leaves accessibility while they wait to show.
-    private fun follow(activity: Activity) {
-        val content = contentOf(activity) ?: return
-        for ((row, tabs) in rows) {
-            val host = row.parent as? View ?: continue
-            if (host !== content && host !is ModalContainer) continue
-            var alpha = tabs.container.alpha
-            var current: View? = tabs
-            while (current != null && current !== host) {
-                alpha *= current.alpha
-                current = current.parent as? View
-            }
-            if (row.alpha != alpha) row.alpha = alpha
-            // The row goes with the bar's container: a ride, a slide, the hide on scroll.
-            val container = tabs.container
-            if (row.translationX != container.translationX) row.translationX = container.translationX
-            if (row.translationY != container.translationY) row.translationY = container.translationY
-            val mode = if (row.hiddenFromAccessibility()) {
-                View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
-            } else {
-                View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
-            }
-            if (row.importantForAccessibility != mode) row.importantForAccessibility = mode
-        }
-    }
-}

package/android/src/main/java/dev/apexnative/navigation/views/element/ElementStub.kt

@@ -1,31 +0,0 @@
-package dev.apexnative.navigation.views.element
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.Canvas
-import android.view.MotionEvent
-import android.view.View
-
-/**
- * The empty view that stands in an element's place in its parent while the element is in the transition layer: the same
- * id at the same index with the same layout, so Fabric finds the parent's children as it left them; React removing it
- * removes the element for good. It has no `nativeID`, so no search finds it as the element. It draws nothing and takes
- * no touches. Main thread only.
- */
-@SuppressLint("ViewConstructor")
-internal class ElementStub(context: Context, element: View) : View(context) {
-    init {
-        id = element.id
-        importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO
-        isClickable = false
-        isFocusable = false
-    }
-
-    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) =
-        setMeasuredDimension(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec))
-
-    override fun draw(canvas: Canvas) = Unit
-
-    @SuppressLint("ClickableViewAccessibility")
-    override fun onTouchEvent(event: MotionEvent?): Boolean = false
-}

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/ImageMatrixAnimator.kt

@@ -1,138 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import android.graphics.Matrix
-import android.view.View
-import android.view.ViewOutlineProvider
-import android.widget.ImageView
-import androidx.core.animation.doOnEnd
-import androidx.core.animation.doOnStart
-import com.facebook.react.views.view.ReactViewGroup
-import dev.apexnative.navigation.utils.borderRadius
-import dev.apexnative.navigation.views.animations.ValueInterpolation
-import dev.apexnative.navigation.views.element.TransitionLayer
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.roundToInt
-
-/**
- * A shared image of another kind (an `ImageView` that isn't React Native's): its place by a translation; its image
- * matrix from `from`'s fit (`centerCrop`, `fitXY`, `fitCenter`, `centerInside`) to its own, the part seen from `from`'s
- * size to its own, the corner radius of the parent that clips it (`borderRadius` with `overflow: hidden`) by its
- * outline. Another fit: the pair moves without the change of its matrix, and a line goes to the log. Everything goes
- * back as it was at the end. Main thread only.
- */
-internal class ImageMatrixAnimator(
-    private val from: ImageView,
-    private val to: ImageView,
-    private val layer: TransitionLayer,
-    /** The parents the views are clipped by in their screens: [to]'s is the one it had before the layer. */
-    private val fromParent: View?,
-    private val toParent: View?,
-    private val id: String,
-    private val log: (String) -> Unit,
-) {
-    /** The animator; none when [to] has no place in the layer. */
-    fun create(): Animator? {
-        val geometry = FlightGeometry.of(from, to, layer) ?: return null
-        val toRect = geometry.to
-        val fromFit = from.scaleType
-        val toFit = to.scaleType
-        // The image whose matrix changes; none when a fit isn't one of the four or there is no image to fit.
-        val image = to.drawable?.takeIf {
-            fromFit in FITS && toFit in FITS && it.intrinsicWidth > 0 && it.intrinsicHeight > 0
-        }
-        val fits = image != null
-        if (!fits) log("The image '$id' fits by ${fromFit.name} and ${toFit.name}: it moves without a change of fit")
-        val fromRadius = clipRadius(fromParent) * geometry.fromScale
-        val toRadius = clipRadius(toParent)
-        val outline = FlightOutline()
-        var savedProvider: ViewOutlineProvider? = null
-        var savedClip = false
-        val savedMatrix = Matrix(to.imageMatrix)
-        val start = FloatArray(MATRIX)
-        val end = FloatArray(MATRIX)
-        val values = FloatArray(MATRIX)
-        val matrix = Matrix()
-        return MoveAnimator().apply {
-            fun frame(time: Float) {
-                val f = curve.getInterpolation(time)
-                val left = ValueInterpolation.number(geometry.from.left, toRect.left, f, time)
-                val top = ValueInterpolation.number(geometry.from.top, toRect.top, f, time)
-                val width = ValueInterpolation.number(geometry.from.width(), toRect.width(), f, time).roundToInt()
-                val height = ValueInterpolation.number(geometry.from.height(), toRect.height(), f, time).roundToInt()
-                layer.place(to, toRect.left.toInt(), toRect.top.toInt(), width, height)
-                to.translationX = left - toRect.left
-                to.translationY = top - toRect.top
-                outline.width = width
-                outline.height = height
-                outline.radius = ValueInterpolation.number(fromRadius, toRadius, f, time)
-                to.invalidateOutline()
-                if (image != null) {
-                    val imageWidth = image.intrinsicWidth
-                    val imageHeight = image.intrinsicHeight
-                    fitMatrix(fromFit, imageWidth, imageHeight, width, height).getValues(start)
-                    fitMatrix(toFit, imageWidth, imageHeight, width, height).getValues(end)
-                    for (i in 0 until MATRIX) values[i] = ValueInterpolation.number(start[i], end[i], f, time)
-                    matrix.setValues(values)
-                    to.imageMatrix = matrix
-                }
-            }
-            doOnStart {
-                savedProvider = to.outlineProvider
-                savedClip = to.clipToOutline
-                to.outlineProvider = outline
-                to.clipToOutline = true
-                if (fits) to.scaleType = ImageView.ScaleType.MATRIX
-                frame(0f)
-            }
-            addUpdateListener { frame(it.animatedFraction) }
-            doOnEnd {
-                if (fits) {
-                    to.scaleType = toFit
-                    to.imageMatrix = savedMatrix
-                }
-                to.outlineProvider = savedProvider
-                to.clipToOutline = savedClip
-                to.translationX = 0f
-                to.translationY = 0f
-                layer.place(to, toRect.left.toInt(), toRect.top.toInt(), toRect.width().toInt(),
-                    toRect.height().toInt())
-            }
-        }
-    }
-
-    // The radius of a React parent that clips what is in it; 0 for another.
-    private fun clipRadius(parent: View?): Float =
-        (parent as? ReactViewGroup)?.takeIf { it.overflow == HIDDEN }?.borderRadius ?: 0f
-
-    private companion object {
-        const val MATRIX = 9
-        const val HIDDEN = "hidden"
-        val FITS = setOf(
-            ImageView.ScaleType.CENTER_CROP,
-            ImageView.ScaleType.FIT_XY,
-            ImageView.ScaleType.FIT_CENTER,
-            ImageView.ScaleType.CENTER_INSIDE,
-        )
-
-        // The matrix of a fit of an image of [imageWidth] × [imageHeight] into [width] × [height].
-        fun fitMatrix(fit: ImageView.ScaleType, imageWidth: Int, imageHeight: Int, width: Int, height: Int): Matrix {
-            val sx = width.toFloat() / imageWidth
-            val sy = height.toFloat() / imageHeight
-            val matrix = Matrix()
-            if (fit == ImageView.ScaleType.FIT_XY) {
-                matrix.setScale(sx, sy)
-                return matrix
-            }
-            val scale = when (fit) {
-                ImageView.ScaleType.CENTER_CROP -> max(sx, sy)
-                ImageView.ScaleType.CENTER_INSIDE -> min(1f, min(sx, sy))
-                else -> min(sx, sy)
-            }
-            matrix.setScale(scale, scale)
-            matrix.postTranslate((width - imageWidth * scale) / 2f, (height - imageHeight * scale) / 2f)
-            return matrix
-        }
-    }
-}

package/android/src/main/java/dev/apexnative/navigation/views/element/animators/PlainViewAnimator.kt

@@ -1,88 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import android.view.View
-import android.view.ViewOutlineProvider
-import androidx.core.animation.doOnEnd
-import androidx.core.animation.doOnStart
-import com.facebook.react.uimanager.BackgroundStyleApplicator
-import com.facebook.react.uimanager.style.BorderRadiusProp
-import dev.apexnative.navigation.utils.borderRadius
-import dev.apexnative.navigation.views.animations.ValueInterpolation
-import dev.apexnative.navigation.views.element.TransitionLayer
-import kotlin.math.roundToInt
-
-/**
- * A shared React view without children moves itself: from `from`'s place on the screen to its own by a translation; its
- * size and corner radius by an outline that grows from `from`'s (at the scale of its parents) to its own while it is
- * laid out at the larger of the two sizes; its own radius taken off meanwhile and put back as it was; its background
- * color from `from`'s to its own in Lab, ending exactly on its own (`BackgroundStyleApplicator`); its rotation from
- * `from`'s to its own. Main thread only.
- */
-internal class PlainViewAnimator(
-    private val from: View,
-    private val to: View,
-    private val layer: TransitionLayer,
-) {
-    /** The animator; none when [to] has no place in the layer. */
-    fun create(): Animator? {
-        val geometry = FlightGeometry.of(from, to, layer) ?: return null
-        val fromRadius = from.borderRadius * geometry.fromScale
-        val toRadius = to.borderRadius
-        val fromColor = BackgroundStyleApplicator.getBackgroundColor(from)
-        val toColor = BackgroundStyleApplicator.getBackgroundColor(to)
-        val fromRotation = from.rotation
-        val toRotation = to.rotation
-        val ownRadius = BackgroundStyleApplicator.getBorderRadius(to, RADIUS)
-        val outline = FlightOutline()
-        var savedProvider: ViewOutlineProvider? = null
-        var savedClip = false
-        val (width, height) = geometry.largest
-        val toRect = geometry.to
-        return MoveAnimator().apply {
-            fun frame(time: Float) {
-                val f = curve.getInterpolation(time)
-                val left = ValueInterpolation.number(geometry.from.left, toRect.left, f, time)
-                val top = ValueInterpolation.number(geometry.from.top, toRect.top, f, time)
-                to.translationX = left - toRect.left
-                to.translationY = top - toRect.top
-                val from = geometry.from
-                outline.width = ValueInterpolation.number(from.width(), toRect.width(), f, time).roundToInt()
-                outline.height = ValueInterpolation.number(from.height(), toRect.height(), f, time).roundToInt()
-                outline.radius = ValueInterpolation.number(fromRadius, toRadius, f, time)
-                to.invalidateOutline()
-                if (fromColor != toColor) {
-                    val color = ValueInterpolation.color(fromColor, toColor, f, time)
-                    BackgroundStyleApplicator.setBackgroundColor(to, color)
-                }
-                to.rotation = ValueInterpolation.number(fromRotation, toRotation, f, time)
-            }
-            doOnStart {
-                savedProvider = to.outlineProvider
-                savedClip = to.clipToOutline
-                if (ownRadius != null) BackgroundStyleApplicator.setBorderRadius(to, RADIUS, null)
-                to.outlineProvider = outline
-                to.clipToOutline = true
-                layer.place(to, toRect.left.toInt(), toRect.top.toInt(), width, height)
-                frame(0f)
-            }
-            addUpdateListener { frame(it.animatedFraction) }
-            // A cancelled flight ends too: the view goes back whole.
-            doOnEnd {
-                to.translationX = 0f
-                to.translationY = 0f
-                to.rotation = toRotation
-                if (fromColor != toColor) BackgroundStyleApplicator.setBackgroundColor(to, toColor)
-                if (ownRadius != null) BackgroundStyleApplicator.setBorderRadius(to, RADIUS, ownRadius)
-                to.outlineProvider = savedProvider
-                to.clipToOutline = savedClip
-                layer.place(to, toRect.left.toInt(), toRect.top.toInt(), toRect.width().toInt(),
-                    toRect.height().toInt())
-            }
-        }
-    }
-
-    private companion object {
-        val RADIUS = BorderRadiusProp.BORDER_RADIUS
-    }
-}