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

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

@@ -1,33 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import android.view.View
-import dev.apexnative.navigation.options.SharedElementTransitionOptions
-
-/**
- * One animator of a shared element: how [from], on the screen that goes, becomes [to], on the screen that comes, when
- * both are of [type]. The core picks one by the views' classes (`SharedAnimatorFactory`) and runs it in the
- * transition's layer.
- */
-abstract class PropertyAnimatorCreator<T : View>(
-    protected val from: View,
-    protected val to: View,
-    private val type: Class<T>,
-) {
-    /** Whether this animator takes part: both views are of its type and differ in what it animates. */
-    fun shouldAnimate(): Boolean {
-        if (!type.isInstance(from) || !type.isInstance(to)) return false
-        val fromChild = type.cast(from) ?: return false
-        val toChild = type.cast(to) ?: return false
-        return shouldAnimateProperty(fromChild, toChild)
-    }
-
-    /** Whether [fromChild] and [toChild] differ in what this animator animates. */
-    abstract fun shouldAnimateProperty(fromChild: T, toChild: T): Boolean
-
-    /**
-     * The animator of the pair for [options]; the core gives it the pair's duration, delay and curve (each animator
-     * its own, never through a set around it).
-     */
-    abstract fun create(options: SharedElementTransitionOptions): Animator
-}

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

@@ -1,66 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import androidx.core.animation.doOnEnd
-import androidx.core.animation.doOnStart
-import com.facebook.drawee.drawable.ScalingUtils
-import com.facebook.react.views.image.ReactImageView
-import dev.apexnative.navigation.views.animations.ValueInterpolation
-import dev.apexnative.navigation.views.element.TransitionLayer
-import kotlin.math.roundToInt
-
-/**
- * A shared React image: its place by a translation from `from`'s on the screen; its content by Fresco's scale type
- * going from `from`'s fit to its own (`ScalingUtils.InterpolatingScaleType`); the part seen from `from`'s size to its
- * own (it is laid out at the size of each frame); its rotation from `from`'s to its own; Fresco's own fade off
- * meanwhile. Everything goes back as it was at the end. Main thread only.
- */
-internal class ReactImageAnimator(
-    private val from: ReactImageView,
-    private val to: ReactImageView,
-    private val layer: TransitionLayer,
-) {
-    /** The animator; none when [to] has no place in the layer or no hierarchy. */
-    fun create(): Animator? {
-        if (!from.hasHierarchy() || !to.hasHierarchy()) return null
-        val geometry = FlightGeometry.of(from, to, layer) ?: return null
-        val toRect = geometry.to
-        val toType = to.hierarchy.actualImageScaleType ?: ScalingUtils.ScaleType.CENTER_CROP
-        val fromType = from.hierarchy.actualImageScaleType ?: ScalingUtils.ScaleType.CENTER_CROP
-        val scale = ScalingUtils.InterpolatingScaleType(fromType, toType)
-        val fromRotation = from.rotation
-        val toRotation = to.rotation
-        var savedFade = 0
-        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
-                scale.setValue(if (time >= 1f) 1f else f)
-                to.rotation = ValueInterpolation.number(fromRotation, toRotation, f, time)
-                to.invalidate()
-            }
-            doOnStart {
-                savedFade = to.hierarchy.fadeDuration
-                to.hierarchy.fadeDuration = 0
-                to.hierarchy.setActualImageScaleType(scale)
-                frame(0f)
-            }
-            addUpdateListener { frame(it.animatedFraction) }
-            doOnEnd {
-                to.hierarchy.setActualImageScaleType(toType)
-                to.hierarchy.fadeDuration = savedFade
-                to.translationX = 0f
-                to.translationY = 0f
-                to.rotation = toRotation
-                layer.place(to, toRect.left.toInt(), toRect.top.toInt(), toRect.width().toInt(),
-                    toRect.height().toInt())
-            }
-        }
-    }
-}

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

@@ -1,179 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import android.graphics.Canvas
-import android.graphics.ColorFilter
-import android.graphics.Picture
-import android.graphics.PixelFormat
-import android.graphics.PointF
-import android.graphics.drawable.Drawable
-import android.text.Layout
-import android.view.View
-import android.view.ViewGroup
-import android.widget.TextView
-import androidx.core.animation.doOnEnd
-import androidx.core.animation.doOnStart
-import com.facebook.react.views.text.ReactTextView
-import dev.apexnative.navigation.options.SharedElementTransitionOptions
-import dev.apexnative.navigation.utils.TextViewUtils
-import dev.apexnative.navigation.utils.ViewUtils
-import kotlin.math.roundToInt
-
-// The text moves as two pictures of itself, of the text that goes away and of the text that comes, the same text or
-// another. Both keep their proportions, scaled by the font size from a point of the first line, and one turns into the
-// other in a quarter of the move: at its start when the text grows, at its end when it shrinks, so the larger picture
-// shows most of the way (as on iOS). The pictures are drawing commands, not pixels: they stay sharp at any scale and
-// keep the colors, emoji and background of the text. They are drawn in the overlay of the transition layer while `to`
-// is hidden.
-class TextChangeAnimator(from: View, to: View) : PropertyAnimatorCreator<ReactTextView>(from, to, ReactTextView::class.java) {
-    private val pictures by lazy { pictures() }
-
-    override fun shouldAnimateProperty(fromChild: ReactTextView, toChild: ReactTextView): Boolean {
-        val fromPlace = ViewUtils.getLocationOnScreen(from)
-        val toPlace = ViewUtils.getLocationOnScreen(to)
-        return (fromChild.text.toString() != toChild.text.toString() ||
-                TextViewUtils.getTextSize(fromChild) != TextViewUtils.getTextSize(toChild) || fromPlace != toPlace
-                ) && pictures != null
-    }
-
-    override fun create(options: SharedElementTransitionOptions): Animator {
-        val (start, end) = checkNotNull(pictures)
-        val layer = to.parent as ViewGroup
-        val drawable = TextMorphDrawable(start, end)
-        // Everything changes between the start and the end of the animation: a cancelled one ends too.
-        return MoveAnimator().apply {
-            doOnStart {
-                drawable.setBounds(0, 0, layer.width, layer.height)
-                layer.overlay.add(drawable)
-                to.alpha = 0f
-            }
-            addUpdateListener {
-                drawable.update(it.animatedFraction, curve.getInterpolation(it.animatedFraction))
-                layer.invalidate()
-            }
-            doOnEnd {
-                layer.overlay.remove(drawable)
-                layer.invalidate()
-                to.alpha = end.alpha
-            }
-        }
-    }
-
-    // `to` is in the transition layer already, at its margins (the coordinates of the other animators); `from` is where
-    // it is on the screen. Texts that line up the same way go from that point of their first lines (the same text lies
-    // over itself); others from the start of the line, as on iOS: a centered text no longer sticks out of a text at the
-    // start.
-    private fun pictures(): Pair<TextPicture, TextPicture>? {
-        if (to.parent !is ViewGroup) return null
-        val toPlace = to.layoutParams as? ViewGroup.MarginLayoutParams ?: return null
-        val fromLayout = (from as TextView).layout ?: return null
-        val toLayout = (to as TextView).layout ?: return null
-        val edge = lineEdge(fromLayout).takeIf { it == lineEdge(toLayout) } ?: LineEdge.START
-        val fromPlace = ViewUtils.getLocationOnScreen(from)
-            .apply { ViewUtils.getLocationOnScreen(to.parent as View).let { offset(-it.x, -it.y) } }
-        val start = TextPicture.of(from, fromPlace.x, fromPlace.y, edge) ?: return null
-        val end = TextPicture.of(to, toPlace.leftMargin, toPlace.topMargin, edge) ?: return null
-        return start to end
-    }
-}
-
-// A text's picture, the point of its first line it is scaled from (in the view) and where that point is in the
-// transition layer, its font size and opacity.
-private class TextPicture(
-    val picture: Picture,
-    val anchor: PointF,
-    val position: PointF,
-    val fontSize: Float,
-    val alpha: Float
-) {
-    companion object {
-        fun of(view: TextView, left: Int, top: Int, edge: LineEdge): TextPicture? {
-            val layout = view.layout ?: return null
-            val fontSize = TextViewUtils.getTextSize(view).takeIf { it > 0 } ?: view.textSize
-            if (view.width <= 0 || view.height <= 0 || layout.lineCount == 0 || fontSize <= 0) return null
-            // Without a picture (recording failed) the text goes to its place at once, as a different text does.
-            val picture = recordPicture(view) ?: return null
-            val anchor = PointF(
-                view.totalPaddingLeft + edgeX(layout, edge),
-                view.totalPaddingTop + layout.getLineBaseline(0).toFloat()
-            )
-            return TextPicture(picture, anchor, PointF(left + anchor.x, top + anchor.y), fontSize, view.alpha)
-        }
-
-        // That point of the first line, in the direction of the text.
-        private fun edgeX(layout: Layout, edge: LineEdge): Float {
-            val left = layout.getLineLeft(0)
-            val right = layout.getLineRight(0)
-            val rightToLeft = layout.getParagraphDirection(0) == Layout.DIR_RIGHT_TO_LEFT
-            return when (edge) {
-                LineEdge.CENTER -> (left + right) / 2
-                LineEdge.START -> if (rightToLeft) right else left
-                LineEdge.END -> if (rightToLeft) left else right
-            }
-        }
-    }
-}
-
-// Where the lines of a text line up: their start, center or end, in the direction of the text.
-private enum class LineEdge { START, CENTER, END }
-
-// ALIGN_LEFT and ALIGN_RIGHT are hidden constants, for Gravity.LEFT and RIGHT.
-private fun lineEdge(layout: Layout): LineEdge {
-    val rightToLeft = layout.getParagraphDirection(0) == Layout.DIR_RIGHT_TO_LEFT
-    return when (layout.getParagraphAlignment(0).name) {
-        "ALIGN_CENTER" -> LineEdge.CENTER
-        "ALIGN_OPPOSITE" -> LineEdge.END
-        "ALIGN_LEFT" -> if (rightToLeft) LineEdge.END else LineEdge.START
-        "ALIGN_RIGHT" -> if (rightToLeft) LineEdge.START else LineEdge.END
-        else -> LineEdge.START
-    }
-}
-
-// Both pictures where the move has brought the text: the font size and the point of the first line go from the start
-// to the end along the transition's curve, the pictures change over by the clock.
-private class TextMorphDrawable(private val start: TextPicture, private val end: TextPicture) : Drawable() {
-    private val grows = end.fontSize >= start.fontSize
-    private var progress = 0f
-    private var changeOver = 0f
-
-    fun update(time: Float, progress: Float) {
-        this.progress = progress
-        val changeOverStart = if (grows) 0f else 1f - CHANGE_OVER
-        changeOver = ((time - changeOverStart) / CHANGE_OVER).coerceIn(0f, 1f)
-    }
-
-    override fun draw(canvas: Canvas) {
-        val x = start.position.x + (end.position.x - start.position.x) * progress
-        val y = start.position.y + (end.position.y - start.position.y) * progress
-        val fontSize = start.fontSize + (end.fontSize - start.fontSize) * progress
-        draw(canvas, start, x, y, fontSize, 1f - changeOver)
-        draw(canvas, end, x, y, fontSize, changeOver)
-    }
-
-    private fun draw(canvas: Canvas, text: TextPicture, x: Float, y: Float, fontSize: Float, shown: Float) {
-        val alpha = (shown * text.alpha * 255).roundToInt().coerceIn(0, 255)
-        if (alpha == 0) return
-        val scale = fontSize / text.fontSize
-        val count = canvas.save()
-        canvas.translate(x, y)
-        canvas.scale(scale, scale)
-        canvas.translate(-text.anchor.x, -text.anchor.y)
-        // The picture fades as a whole: its letters and background don't show through each other.
-        if (alpha < 255) {
-            canvas.saveLayerAlpha(0f, 0f, text.picture.width.toFloat(), text.picture.height.toFloat(), alpha)
-        }
-        canvas.drawPicture(text.picture)
-        canvas.restoreToCount(count)
-    }
-
-    override fun setAlpha(alpha: Int) = Unit
-
-    override fun setColorFilter(colorFilter: ColorFilter?) = Unit
-
-    @Deprecated("Deprecated in Java")
-    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
-
-    private companion object {
-        const val CHANGE_OVER = 0.25f
-    }
-}

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

@@ -1,139 +0,0 @@
-package dev.apexnative.navigation.views.element.animators
-
-import android.animation.Animator
-import android.graphics.Canvas
-import android.graphics.ColorFilter
-import android.graphics.Paint
-import android.graphics.Picture
-import android.graphics.PixelFormat
-import android.graphics.PorterDuff
-import android.graphics.PorterDuffXfermode
-import android.graphics.RectF
-import android.graphics.drawable.Drawable
-import android.view.View
-import android.view.ViewGroup
-import androidx.core.animation.doOnEnd
-import androidx.core.animation.doOnStart
-import com.facebook.react.views.view.ReactViewGroup
-import dev.apexnative.navigation.options.SharedElementTransitionOptions
-import dev.apexnative.navigation.utils.ViewUtils
-import dev.apexnative.navigation.utils.borderRadius
-import dev.apexnative.navigation.utils.computeInheritedScale
-import kotlin.math.roundToInt
-
-// A view with children moves as two pictures of itself, as on iOS: of the view that goes away and of the one that
-// comes, each with its children. The copy goes from the place, size and corner radius of the one to those of the other,
-// both pictures fill it, and the picture of the destination shows over the other on the way. The pictures are drawing
-// commands: an avatar's letter grows sharp. They are drawn in the overlay of the transition layer while `to` is hidden,
-// and nothing else moves the pair. A view without children moves itself, its outline growing, as before.
-class ViewChangeAnimator(from: View, to: View) : PropertyAnimatorCreator<ReactViewGroup>(from, to, ReactViewGroup::class.java) {
-    private val pictures by lazy { pictures() }
-
-    override fun shouldAnimateProperty(fromChild: ReactViewGroup, toChild: ReactViewGroup): Boolean =
-            (fromChild.childCount > 0 || toChild.childCount > 0) && pictures != null
-
-    override fun create(options: SharedElementTransitionOptions): Animator {
-        val (start, end) = checkNotNull(pictures)
-        val layer = to.parent as ViewGroup
-        val drawable = ViewMorphDrawable(start, end)
-        // Everything changes between the start and the end of the animation: a cancelled one ends too.
-        return MoveAnimator().apply {
-            doOnStart {
-                drawable.setBounds(0, 0, layer.width, layer.height)
-                layer.overlay.add(drawable)
-                to.alpha = 0f
-            }
-            addUpdateListener {
-                drawable.progress = curve.getInterpolation(it.animatedFraction)
-                layer.invalidate()
-            }
-            doOnEnd {
-                layer.overlay.remove(drawable)
-                layer.invalidate()
-                to.alpha = end.alpha
-            }
-        }
-    }
-
-    // `to` is in the transition layer already, at its margins (the coordinates of the other animators); `from` is where
-    // it is on the screen, at the scale of its parents.
-    private fun pictures(): Pair<ViewPicture, ViewPicture>? {
-        if (to.parent !is ViewGroup) return null
-        val toPlace = to.layoutParams as? ViewGroup.MarginLayoutParams ?: return null
-        val fromPlace = ViewUtils.getLocationOnScreen(from)
-            .apply { ViewUtils.getLocationOnScreen(to.parent as View).let { offset(-it.x, -it.y) } }
-        val (scaleX, scaleY) = computeInheritedScale(from)
-        val fromRect = RectF(0f, 0f, from.width * scaleX, from.height * scaleY).apply {
-            offset(fromPlace.x.toFloat(), fromPlace.y.toFloat())
-        }
-        val toRect = RectF(0f, 0f, to.width.toFloat(), to.height.toFloat()).apply {
-            offset(toPlace.leftMargin.toFloat(), toPlace.topMargin.toFloat())
-        }
-        val start = ViewPicture.of(from as ReactViewGroup, fromRect, scaleX) ?: return null
-        val end = ViewPicture.of(to as ReactViewGroup, toRect, 1f) ?: return null
-        return start to end
-    }
-}
-
-// A view's picture, its place in the transition layer, its corner radius there and its opacity.
-private class ViewPicture(val picture: Picture, val rect: RectF, val radius: Float, val alpha: Float) {
-    companion object {
-        fun of(view: ReactViewGroup, rect: RectF, scale: Float): ViewPicture? {
-            if (view.width <= 0 || view.height <= 0) return null
-            val picture = recordPicture(view) ?: return null
-            return ViewPicture(picture, rect, view.borderRadius * scale, view.alpha)
-        }
-    }
-}
-
-// The copy where the move has brought it: its place, size and corner radius go from the start to the end along the
-// transition's curve, and so does the picture of the end over the picture of the start.
-private class ViewMorphDrawable(private val start: ViewPicture, private val end: ViewPicture) : Drawable() {
-    var progress = 0f
-    private val rect = RectF()
-    private val maskPaint = Paint(Paint.ANTI_ALIAS_FLAG)
-    // What is drawn over the mask keeps only the mask's pixels: the corners stay smooth (a clip path on the hardware
-    // canvas is not anti-aliased).
-    private val contentPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN) }
-
-    override fun draw(canvas: Canvas) {
-        rect.set(
-            lerp(start.rect.left, end.rect.left),
-            lerp(start.rect.top, end.rect.top),
-            lerp(start.rect.right, end.rect.right),
-            lerp(start.rect.bottom, end.rect.bottom)
-        )
-        if (rect.isEmpty) return
-        val radius = lerp(start.radius, end.radius)
-        val count = canvas.saveLayer(rect, null)
-        canvas.drawRoundRect(rect, radius, radius, maskPaint)
-        canvas.saveLayer(rect, contentPaint)
-        draw(canvas, start, start.alpha)
-        draw(canvas, end, end.alpha * progress)
-        canvas.restoreToCount(count)
-    }
-
-    // A picture fills the copy, as on iOS.
-    private fun draw(canvas: Canvas, view: ViewPicture, shown: Float) {
-        val alpha = (shown * 255).roundToInt().coerceIn(0, 255)
-        if (alpha == 0) return
-        val width = view.picture.width.toFloat()
-        val height = view.picture.height.toFloat()
-        val count = canvas.save()
-        canvas.translate(rect.left, rect.top)
-        canvas.scale(rect.width() / width, rect.height() / height)
-        // The picture fades as a whole: its children and background don't show through each other.
-        if (alpha < 255) canvas.saveLayerAlpha(0f, 0f, width, height, alpha)
-        canvas.drawPicture(view.picture)
-        canvas.restoreToCount(count)
-    }
-
-    private fun lerp(from: Float, to: Float) = from + (to - from) * progress
-
-    override fun setAlpha(alpha: Int) = Unit
-
-    override fun setColorFilter(colorFilter: ColorFilter?) = Unit
-
-    @Deprecated("Deprecated in Java")
-    override fun getOpacity(): Int = PixelFormat.TRANSLUCENT
-}

package/ios/Layouts/Screen/ANNScreenInsets.h

@@ -1,30 +0,0 @@
-#import "ANNEventEmitter.h"
-#import <UIKit/UIKit.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/// Posted on the main queue when the padding of a screen's safe area view changed; the object is the screen id.
-extern NSNotificationName const ANNScreenSafeAreaPaddingDidChangeNotification;
-
-/// The safe area of each screen: 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`. Main queue, but the reads.
-@interface ANNScreenInsets : NSObject
-
-/// Keeps the screen's insets and padding, and tells when they changed.
-+ (void)setInsets:(UIEdgeInsets)insets
-          padding:(UIEdgeInsets)padding
-      forScreenId:(NSString *)screenId
-     eventEmitter:(ANNEventEmitter *)eventEmitter;
-/// The padding of the screen's safe area view; none before the screen was laid out. Main queue.
-+ (UIEdgeInsets)paddingForScreenId:(NSString *)screenId;
-/// `{ top, right, bottom, left }`, or nil before the screen was laid out. Any thread.
-+ (nullable NSDictionary<NSString *, NSNumber *> *)insetsForScreenId:(NSString *)screenId;
-+ (void)removeScreenId:(NSString *)screenId;
-/// Forgets every screen: after a reload the new JavaScript counts its ids anew. Main queue.
-+ (void)removeAll;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenInsets.mm

@@ -1,68 +0,0 @@
-#import "ANNScreenInsets.h"
-
-NSNotificationName const ANNScreenSafeAreaPaddingDidChangeNotification = @"ANNScreenSafeAreaPaddingDidChange";
-
-static NSMutableDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *ANNScreenInsetsById;
-// Main queue only.
-static NSMutableDictionary<NSString *, NSValue *> *ANNScreenPaddingById;
-
-@implementation ANNScreenInsets
-
-+ (void)initialize {
-    if (self == ANNScreenInsets.class) {
-        ANNScreenInsetsById = [NSMutableDictionary new];
-        ANNScreenPaddingById = [NSMutableDictionary new];
-    }
-}
-
-+ (void)setInsets:(UIEdgeInsets)insets
-          padding:(UIEdgeInsets)padding
-      forScreenId:(NSString *)screenId
-     eventEmitter:(ANNEventEmitter *)eventEmitter {
-    NSValue *paddingValue = [NSValue valueWithUIEdgeInsets:padding];
-    if (![ANNScreenPaddingById[screenId] isEqualToValue:paddingValue]) {
-        ANNScreenPaddingById[screenId] = paddingValue;
-        [NSNotificationCenter.defaultCenter postNotificationName:ANNScreenSafeAreaPaddingDidChangeNotification
-                                                          object:screenId];
-    }
-    // JavaScript gets what still covers the content: the edges the safe area view keeps it off are 0.
-    NSDictionary<NSString *, NSNumber *> *value = @{
-        @"top" : @(MAX(insets.top - padding.top, 0)),
-        @"right" : @(MAX(insets.right - padding.right, 0)),
-        @"bottom" : @(MAX(insets.bottom - padding.bottom, 0)),
-        @"left" : @(MAX(insets.left - padding.left, 0)),
-    };
-    @synchronized(ANNScreenInsetsById) {
-        if ([ANNScreenInsetsById[screenId] isEqualToDictionary:value]) {
-            return;
-        }
-        ANNScreenInsetsById[screenId] = value;
-    }
-    [eventEmitter sendScreenInsetsChanged:screenId insets:value];
-}
-
-+ (NSDictionary<NSString *, NSNumber *> *)insetsForScreenId:(NSString *)screenId {
-    @synchronized(ANNScreenInsetsById) {
-        return ANNScreenInsetsById[screenId];
-    }
-}
-
-+ (UIEdgeInsets)paddingForScreenId:(NSString *)screenId {
-    return ANNScreenPaddingById[screenId].UIEdgeInsetsValue;
-}
-
-+ (void)removeScreenId:(NSString *)screenId {
-    [ANNScreenPaddingById removeObjectForKey:screenId];
-    @synchronized(ANNScreenInsetsById) {
-        [ANNScreenInsetsById removeObjectForKey:screenId];
-    }
-}
-
-+ (void)removeAll {
-    [ANNScreenPaddingById removeAllObjects];
-    @synchronized(ANNScreenInsetsById) {
-        [ANNScreenInsetsById removeAllObjects];
-    }
-}
-
-@end

package/ios/Layouts/Tabs/ANNTabsPreloadWindow.h

@@ -1,27 +0,0 @@
-#import <UIKit/UIKit.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/// Where the React views of unselected tabs mount while the tabs render: a window of zero size that clips what it
-/// holds, hidden from accessibility, in the scene of the navigation's main window. Nothing in it is seen and its safe
-/// area views never lay out there: a tab renders its content where it shows. One per tabs node; it goes when it holds
-/// nothing more or with its tabs. Main queue.
-@interface ANNTabsPreloadWindow : UIWindow
-
-/// A new window in the scene of the main window; when the main window has no scene yet, it joins the scene as the main
-/// window connects (`mainWindowSceneDidConnect:`), before it holds anything that could be seen.
-+ (instancetype)preloadWindow;
-
-/// The main window connected to its scene: every live preload window joins it.
-+ (void)mainWindowSceneDidConnect:(UIWindowScene *)windowScene;
-
-/// A reload of the JavaScript: every live preload window hides at once; its views go with their old tabs after the
-/// reload's hold.
-+ (void)hideAllAfterReload;
-
-/// The window goes: it hides and leaves its scene. Its views are the tabs' to take back first.
-- (void)close;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNTabsPreloadWindow.mm

@@ -1,55 +0,0 @@
-#import "ANNTabsPreloadWindow.h"
-#import "ANNAssert.h"
-#import "ApexNavigation+Internal.h"
-
-// Every live preload window, weakly: the reload hides them, the scene's connection moves them. Main queue.
-static NSHashTable<ANNTabsPreloadWindow *> *ANNPreloadWindows(void) {
-    static NSHashTable<ANNTabsPreloadWindow *> *windows;
-    if (!windows) {
-        windows = [NSHashTable weakObjectsHashTable];
-    }
-    return windows;
-}
-
-@implementation ANNTabsPreloadWindow
-
-+ (instancetype)preloadWindow {
-    ANNAssertMainQueue();
-    UIWindowScene *scene = ApexNavigation.mainWindow.windowScene;
-    ANNTabsPreloadWindow *window =
-        scene ? [[self alloc] initWithWindowScene:scene] : [[self alloc] initWithFrame:CGRectZero];
-    window.frame = CGRectZero;
-    window.clipsToBounds = YES;
-    window.userInteractionEnabled = NO;
-    window.accessibilityElementsHidden = YES;
-    window.backgroundColor = UIColor.clearColor;
-    // Under every window of the app: nothing of it is ever drawn over the navigation.
-    window.windowLevel = UIWindowLevelNormal - 1;
-    window.hidden = NO;
-    [ANNPreloadWindows() addObject:window];
-    return window;
-}
-
-+ (void)mainWindowSceneDidConnect:(UIWindowScene *)windowScene {
-    ANNAssertMainQueue();
-    for (ANNTabsPreloadWindow *window in ANNPreloadWindows().allObjects) {
-        if (window.windowScene != windowScene) {
-            window.windowScene = windowScene;
-        }
-    }
-}
-
-+ (void)hideAllAfterReload {
-    ANNAssertMainQueue();
-    for (ANNTabsPreloadWindow *window in ANNPreloadWindows().allObjects) {
-        window.hidden = YES;
-    }
-}
-
-- (void)close {
-    self.hidden = YES;
-    [ANNPreloadWindows() removeObject:self];
-    self.windowScene = nil;
-}
-
-@end