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

package/ios/Layouts/Screen/ANNScreenEnvironment.mm

@@ -0,0 +1,181 @@
+#import "ANNScreenEnvironment.h"
+#import "ANNEventContract.h"
+
+// One screen's record; nil for a fact not known yet (not laid out, no regions, outside a pair). Changed and read only
+// under the lock of `ANNEnvironmentById`; the values are immutable, so a reader keeps what it took.
+@interface ANNScreenEnvironmentRecord : NSObject
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSNumber *> *insets;
+@property(nonatomic, strong, nullable) NSValue *padding;
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSArray *> *regions;
+@property(nonatomic, copy, nullable) NSDictionary<NSString *, id> *arrangement;
+@end
+
+@implementation ANNScreenEnvironmentRecord
+@end
+
+// Written on the main queue, read from any thread: every access holds its lock.
+static NSMutableDictionary<NSString *, ANNScreenEnvironmentRecord *> *ANNEnvironmentById;
+// The safe area views of each screen, by its id (the id's value: the view's id and the core's are other strings), held
+// weakly. Main queue only.
+static NSMutableDictionary<NSString *, NSHashTable<id<ANNScreenPaddingListener>> *>
+    *ANNPaddingListenersById;
+
+@implementation ANNScreenEnvironment
+
++ (void)initialize {
+    if (self == ANNScreenEnvironment.class) {
+        ANNEnvironmentById = [NSMutableDictionary new];
+        ANNPaddingListenersById = [NSMutableDictionary new];
+    }
+}
+
+// The screen's record, a new one for a screen not kept yet. Under the lock.
++ (ANNScreenEnvironmentRecord *)recordOf:(NSString *)screenId {
+    ANNScreenEnvironmentRecord *record = ANNEnvironmentById[screenId];
+    if (!record) {
+        record = [ANNScreenEnvironmentRecord new];
+        ANNEnvironmentById[screenId] = record;
+    }
+    return record;
+}
+
+#pragma mark - Insets and padding
+
++ (void)setInsets:(UIEdgeInsets)insets
+          padding:(UIEdgeInsets)padding
+      forScreenId:(NSString *)screenId
+     eventEmitter:(ANNEventEmitter *)eventEmitter {
+    NSValue *paddingValue = [NSValue valueWithUIEdgeInsets:padding];
+    // JavaScript gets what still covers the content: the edges the safe area view keeps it off are 0.
+    const auto &keys = ANNEventContract.ScreenInsetsChanged;
+    NSDictionary<NSString *, NSNumber *> *value = @{
+        keys.top : @(MAX(insets.top - padding.top, 0)),
+        keys.right : @(MAX(insets.right - padding.right, 0)),
+        keys.bottom : @(MAX(insets.bottom - padding.bottom, 0)),
+        keys.left : @(MAX(insets.left - padding.left, 0)),
+    };
+    BOOL paddingChanged;
+    BOOL insetsChanged;
+    @synchronized(ANNEnvironmentById) {
+        ANNScreenEnvironmentRecord *record = [self recordOf:screenId];
+        paddingChanged = ![record.padding isEqualToValue:paddingValue];
+        insetsChanged = ![record.insets isEqualToDictionary:value];
+        record.padding = paddingValue;
+        record.insets = value;
+    }
+    // The listeners read the padding back, so it is kept before they are told. A copy: a listener may stop or start
+    // listening while it is told.
+    if (paddingChanged) {
+        NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+        for (id<ANNScreenPaddingListener> listener in listeners.allObjects) {
+            [listener screenPaddingDidChange];
+        }
+    }
+    if (insetsChanged) {
+        [eventEmitter sendScreenInsetsChanged:screenId insets:value];
+    }
+}
+
++ (UIEdgeInsets)paddingForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].padding.UIEdgeInsetsValue;
+    }
+}
+
++ (NSDictionary<NSString *, NSNumber *> *)insetsForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].insets;
+    }
+}
+
+#pragma mark - Regions
+
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter {
+    const auto &keys = ANNEventContract.ScreenRegionsChanged;
+    BOOL empty = [regions[keys.division] count] == 0 && [regions[keys.occlusion] count] == 0;
+    @synchronized(ANNEnvironmentById) {
+        NSDictionary<NSString *, NSArray *> *before = ANNEnvironmentById[screenId].regions;
+        if ((!before && empty) || [before isEqualToDictionary:regions]) {
+            return;
+        }
+        [self recordOf:screenId].regions = regions;
+    }
+    [eventEmitter sendScreenRegionsChanged:screenId regions:regions];
+}
+
++ (NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].regions;
+    }
+}
+
+#pragma mark - Arrangement
+
++ (void)setArrangement:(NSDictionary<NSString *, id> *)arrangement
+           forScreenId:(NSString *)screenId
+          eventEmitter:(ANNEventEmitter *)eventEmitter {
+    @synchronized(ANNEnvironmentById) {
+        ANNScreenEnvironmentRecord *record = [self recordOf:screenId];
+        if ([record.arrangement isEqualToDictionary:arrangement]) {
+            return;
+        }
+        record.arrangement = arrangement;
+    }
+    [eventEmitter sendArrangementChanged:screenId state:arrangement];
+}
+
++ (NSDictionary<NSString *, id> *)arrangementForScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        return ANNEnvironmentById[screenId].arrangement;
+    }
+}
+
+#pragma mark - Padding listeners
+
++ (void)addPaddingListener:(id<ANNScreenPaddingListener>)listener
+               forScreenId:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    if (!listeners) {
+        listeners = [NSHashTable weakObjectsHashTable];
+        ANNPaddingListenersById[screenId] = listeners;
+    }
+    [listeners addObject:listener];
+}
+
++ (void)removePaddingListener:(id<ANNScreenPaddingListener>)listener
+                  forScreenId:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    [listeners removeObject:listener];
+    [self forgetListenersOfScreenIdIfNone:screenId];
+}
+
+// A view that went (it doesn't remove itself in its `dealloc`) leaves no entry in the weak table: `allObjects` counts
+// only the live ones. The table of a screen nobody listens to goes with the last one, or with the screen's record.
++ (void)forgetListenersOfScreenIdIfNone:(NSString *)screenId {
+    NSHashTable<id<ANNScreenPaddingListener>> *listeners = ANNPaddingListenersById[screenId];
+    if (listeners && listeners.allObjects.count == 0) {
+        [ANNPaddingListenersById removeObjectForKey:screenId];
+    }
+}
+
+#pragma mark - Removal
+
++ (void)removeScreenId:(NSString *)screenId {
+    @synchronized(ANNEnvironmentById) {
+        [ANNEnvironmentById removeObjectForKey:screenId];
+    }
+    [self forgetListenersOfScreenIdIfNone:screenId];
+}
+
++ (void)removeAll {
+    @synchronized(ANNEnvironmentById) {
+        [ANNEnvironmentById removeAllObjects];
+    }
+    for (NSString *screenId in ANNPaddingListenersById.allKeys) {
+        [self forgetListenersOfScreenIdIfNone:screenId];
+    }
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenPlace.h

@@ -0,0 +1,53 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Where an entry will show on top of a stack, as UIKit lays it out there: the safe area its screens get, and whether
+/// the stack's bar and the tab bar show for it. A screen that waits for its content out of its stack (parked,
+/// `ANNParking`) has no parent view controller, and UIKit gives its view no safe area at all: it lays out with its
+/// place's instead (`placeWhileParked` of `ANNComponentViewController`), so that its root frame, its padding, the
+/// insets JavaScript reads in its first render and its main list are those it has after the push. Nothing of it moves
+/// as the push starts: a list that moved then would lose the large title, which UIKit draws in the list the bar
+/// follows.
+///
+/// The bar's height is UIKit's own: a navigation controller of the core's, unseen in the stack's view for the moment of
+/// the measure, shows an item made like the entry's (title, display mode of the large title, looks, subtitles, prompt,
+/// style, search field) over one like the stack's top, with the stack's bar settings and the entry's toolbar. Main
+/// queue.
+@interface ANNScreenPlace : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The place of `entry` (a screen, or a pair whose screens show under its bar) on top of `stack`, with `options` the
+/// resolved options the stack shows its bar and toolbar by; nil when the stack isn't in a window. Measured again only
+/// when something the measure reads changed since the last one for `entry`.
++ (nullable ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                                  inStack:(UINavigationController *)stack
+                                  options:(ANNNavigationOptions *)options;
+
+/// The same, measured in `host` instead of the stack's view: for a stack UIKit gives no safe area yet (a tab not shown,
+/// parked in the tabs' view), `host` is a view with the safe area the stack gets as it shows (the shown tab's). Nil
+/// when `host` isn't in a window.
++ (nullable ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                                  inStack:(UINavigationController *)stack
+                               measuredIn:(UIView *)host
+                                  options:(ANNNavigationOptions *)options;
+
+/// The place of a screen that is a tab of its own, with no stack: the safe area of `host` (the shown tab's view), no
+/// top bar. Nil when `host` isn't in a window.
++ (nullable ANNScreenPlace *)placeOfScreen:(UIViewController *)screen measuredIn:(UIView *)host;
+
+/// The safe area of the entry's view in the place.
+@property(nonatomic, readonly) UIEdgeInsets safeArea;
+
+/// The stack's bar shows for the entry (`topBar.visible`).
+@property(nonatomic, readonly) BOOL showsTopBar;
+
+/// A tab bar shows at the bottom for the entry: one shows now and the entry doesn't hide it.
+@property(nonatomic, readonly) BOOL showsTabBar;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenPlace.mm

@@ -0,0 +1,205 @@
+#import "ANNScreenPlace.h"
+#import "ANNAssert.h"
+#import "ANNBottomTabsController.h"
+#import <objc/runtime.h>
+
+static const void *ANNScreenPlaceKey = &ANNScreenPlaceKey;
+
+// The measuring navigation controller of each stack: its first item stands for the stack's top, the second for the
+// entry. Weak keys: it goes with its stack.
+static NSMapTable<UINavigationController *, UINavigationController *> *ANNPlaceProbes(void) {
+    static NSMapTable<UINavigationController *, UINavigationController *> *probes;
+    if (!probes) {
+        probes = [NSMapTable weakToStrongObjectsMapTable];
+    }
+    return probes;
+}
+
+static UINavigationController *ANNPlaceProbeOf(UINavigationController *stack) {
+    UINavigationController *probe = [ANNPlaceProbes() objectForKey:stack];
+    if (!probe) {
+        probe = [[UINavigationController alloc] initWithRootViewController:[UIViewController new]];
+        [probe pushViewController:[UIViewController new] animated:NO];
+        [ANNPlaceProbes() setObject:probe forKey:stack];
+    }
+    return probe;
+}
+
+// What UIKit sizes the bar by, from the entry's item. The search field is a field of its own with the same placement:
+// a search controller shows in one item only.
+static void ANNCopyBarItem(UINavigationItem *from, UINavigationItem *to) {
+    to.title = from.title;
+    to.prompt = from.prompt;
+    to.largeTitleDisplayMode = from.largeTitleDisplayMode;
+    to.standardAppearance = from.standardAppearance;
+    to.scrollEdgeAppearance = from.scrollEdgeAppearance;
+    to.compactAppearance = from.compactAppearance;
+    to.compactScrollEdgeAppearance = from.compactScrollEdgeAppearance;
+    to.hidesSearchBarWhenScrolling = from.hidesSearchBarWhenScrolling;
+    to.searchController =
+        from.searchController ? [[UISearchController alloc] initWithSearchResultsController:nil] : nil;
+    if (@available(iOS 16.0, *)) {
+        to.style = from.style;
+        to.preferredSearchBarPlacement = from.preferredSearchBarPlacement;
+    }
+    if (@available(iOS 26.0, *)) {
+        to.attributedSubtitle = from.attributedSubtitle;
+        to.largeAttributedSubtitle = from.largeAttributedSubtitle;
+    }
+}
+
+// Everything the measure reads: the same answer while none of it changed.
+static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationController *stack,
+                                   UIView *host, BOOL showsTopBar, BOOL showsToolbar) {
+    NSMutableString *signature = [NSMutableString
+        stringWithFormat:@"%@|%@|%ld|%p|%p|%p|%p|%p|%d|%d|%d|%d|%@|%@", item.title, item.prompt,
+                         (long)item.largeTitleDisplayMode, item.standardAppearance,
+                         item.scrollEdgeAppearance, item.compactAppearance,
+                         item.compactScrollEdgeAppearance, item.searchController,
+                         item.hidesSearchBarWhenScrolling, stack.navigationBar.prefersLargeTitles,
+                         showsTopBar, showsToolbar, NSStringFromCGSize(host.bounds.size),
+                         NSStringFromUIEdgeInsets(host.safeAreaInsets)];
+    [signature appendFormat:@"|%p|%ld", stack,
+                            (long)stack.topViewController.navigationItem.largeTitleDisplayMode];
+    if (@available(iOS 16.0, *)) {
+        [signature appendFormat:@"|%ld|%ld", (long)item.style, (long)item.preferredSearchBarPlacement];
+    }
+    if (@available(iOS 26.0, *)) {
+        [signature appendFormat:@"|%@|%@", item.attributedSubtitle, item.largeAttributedSubtitle];
+    }
+    return signature;
+}
+
+@implementation ANNScreenPlace {
+    NSString *_signature;
+}
+
+- (instancetype)initWithSafeArea:(UIEdgeInsets)safeArea
+                     showsTopBar:(BOOL)showsTopBar
+                     showsTabBar:(BOOL)showsTabBar
+                       signature:(NSString *)signature {
+    if (self = [super init]) {
+        _safeArea = safeArea;
+        _showsTopBar = showsTopBar;
+        _showsTabBar = showsTabBar;
+        _signature = [signature copy];
+    }
+    return self;
+}
+
++ (ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                         inStack:(UINavigationController *)stack
+                         options:(ANNNavigationOptions *)options {
+    UIView *stackView = stack.viewIfLoaded;
+    if (!stackView) {
+        return nil;
+    }
+    return [self placeOfEntry:entry inStack:stack measuredIn:stackView options:options];
+}
+
++ (ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                         inStack:(UINavigationController *)stack
+                      measuredIn:(UIView *)host
+                         options:(ANNNavigationOptions *)options {
+    ANNAssertMainQueue();
+    UIWindow *window = host.window;
+    if (!window) {
+        return nil;
+    }
+    BOOL showsTopBar = [options.topBar.visible withDefault:YES];
+    BOOL showsToolbar = options.toolbar.shouldShow;
+    BOOL showsTabBar = !entry.hidesBottomBarWhenPushed &&
+                       [[ANNBottomTabsController tabsOf:entry] showsTabBarForScreen:entry];
+    NSString *signature =
+        ANNPlaceSignature(entry.navigationItem, stack, host, showsTopBar, showsToolbar);
+    ANNScreenPlace *kept = objc_getAssociatedObject(entry, ANNScreenPlaceKey);
+    if (kept && kept.showsTabBar == showsTabBar && [kept->_signature isEqualToString:signature]) {
+        return kept;
+    }
+    UIEdgeInsets safeArea = [self measureEntry:entry
+                                       inStack:stack
+                                          host:host
+                                   showsTopBar:showsTopBar
+                                  showsToolbar:showsToolbar];
+    // The measure stands in the host, whose safe area has the tab bar shown now: an entry that hides it gets the
+    // window's bottom there.
+    if (!showsTabBar) {
+        CGFloat tabBar = host.safeAreaInsets.bottom - window.safeAreaInsets.bottom;
+        if (tabBar > 0) {
+            safeArea.bottom = MAX(safeArea.bottom - tabBar, 0);
+        }
+    }
+    ANNScreenPlace *place = [[ANNScreenPlace alloc] initWithSafeArea:safeArea
+                                                          showsTopBar:showsTopBar
+                                                          showsTabBar:showsTabBar
+                                                            signature:signature];
+    objc_setAssociatedObject(entry, ANNScreenPlaceKey, place, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    return place;
+}
+
++ (ANNScreenPlace *)placeOfScreen:(UIViewController *)screen measuredIn:(UIView *)host {
+    ANNAssertMainQueue();
+    UIWindow *window = host.window;
+    if (!window) {
+        return nil;
+    }
+    BOOL showsTabBar = [[ANNBottomTabsController tabsOf:screen] showsTabBarForScreen:screen];
+    UIEdgeInsets safeArea = host.safeAreaInsets;
+    if (!showsTabBar) {
+        CGFloat tabBar = safeArea.bottom - window.safeAreaInsets.bottom;
+        if (tabBar > 0) {
+            safeArea.bottom = MAX(safeArea.bottom - tabBar, 0);
+        }
+    }
+    return [[ANNScreenPlace alloc] initWithSafeArea:safeArea
+                                        showsTopBar:NO
+                                        showsTabBar:showsTabBar
+                                          signature:@""];
+}
+
+// The probe lays out at the host's size in the host, unseen and for this moment only, and leaves no search field
+// behind.
++ (UIEdgeInsets)measureEntry:(UIViewController *)entry
+                     inStack:(UINavigationController *)stack
+                        host:(UIView *)host
+                 showsTopBar:(BOOL)showsTopBar
+                showsToolbar:(BOOL)showsToolbar {
+    UINavigationController *probe = ANNPlaceProbeOf(stack);
+    UIViewController *below = probe.viewControllers.firstObject;
+    UIViewController *top = probe.topViewController;
+    UINavigationBar *bar = probe.navigationBar;
+    UINavigationBar *stackBar = stack.navigationBar;
+    bar.prefersLargeTitles = stackBar.prefersLargeTitles;
+    bar.standardAppearance = stackBar.standardAppearance;
+    bar.scrollEdgeAppearance = stackBar.scrollEdgeAppearance;
+    bar.compactAppearance = stackBar.compactAppearance;
+    below.navigationItem.largeTitleDisplayMode =
+        stack.topViewController.navigationItem.largeTitleDisplayMode;
+    ANNCopyBarItem(entry.navigationItem, top.navigationItem);
+    top.toolbarItems =
+        showsToolbar ? @[ [[UIBarButtonItem alloc] initWithTitle:@" "
+                                                           style:UIBarButtonItemStylePlain
+                                                          target:nil
+                                                          action:nil] ]
+                     : nil;
+    __block UIEdgeInsets safeArea = UIEdgeInsetsZero;
+    UIView *probeView = probe.view;
+    [UIView performWithoutAnimation:^{
+      [probe setNavigationBarHidden:!showsTopBar animated:NO];
+      [probe setToolbarHidden:!showsToolbar animated:NO];
+      probeView.alpha = 0;
+      probeView.userInteractionEnabled = NO;
+      probeView.accessibilityElementsHidden = YES;
+      probeView.frame = host.bounds;
+      [host insertSubview:probeView atIndex:0];
+      [probeView layoutIfNeeded];
+      [top.view layoutIfNeeded];
+      safeArea = top.view.safeAreaInsets;
+      [probeView removeFromSuperview];
+    }];
+    top.navigationItem.searchController = nil;
+    top.toolbarItems = nil;
+    return safeArea;
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenRegions.h

@@ -1,12 +1,10 @@
-#import "ANNEventEmitter.h"
 #import <UIKit/UIKit.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// The reserved regions of each screen (`useReservedRegions`), iOS 27.1: `division`, where the screen divides (the fold
-/// of a partly folded device), and `occlusion`, where hardware covers it (a camera); each a list of
-/// `{ x, y, width, height }`. The native side keeps them on the main queue; JavaScript reads them from its own thread
-/// for a screen's first render, and gets every change as `ANN.ScreenRegionsChanged`.
+/// The reserved regions of a screen (`useReservedRegions`), iOS 27.1: `division`, where the screen divides (the fold of
+/// a partly folded device), and `occlusion`, where hardware covers it (a camera); each a list of
+/// `{ x, y, width, height }`. Measured here; kept for JavaScript by `ANNScreenEnvironment`.
 @interface ANNScreenRegions : NSObject
 
 /// The active regions UIKit reserves in `view`, without the margins it adds around them for interactive content, in
@@ -15,19 +13,6 @@ NS_ASSUME_NONNULL_BEGIN
 + (nullable NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
                                                 inCoordinatesOf:(UIView *)coordinateView;
 
-/// Keeps the screen's regions and tells when they changed. Main queue.
-+ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
-       forScreenId:(NSString *)screenId
-      eventEmitter:(ANNEventEmitter *)eventEmitter;
-
-/// `{ division, occlusion }`, or nil before the screen was laid out. Any thread.
-+ (nullable NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(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/ANNScreenRegions.mm

@@ -1,6 +1,5 @@
 #import "ANNScreenRegions.h"
-
-static NSMutableDictionary<NSString *, NSDictionary<NSString *, NSArray *> *> *ANNScreenRegionsById;
+#import "ANNEventContract.h"
 
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
 // The part of a region inside the screen, CGRectNull for a region outside it (the fold beside a screen of a pair, the
@@ -36,11 +35,12 @@ ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *c
         if (CGRectIsNull(frame)) {
             continue;
         }
+        const auto &keys = ANNEventContract.ScreenRegionRect;
         [rects addObject:@{
-            @"x" : @(frame.origin.x),
-            @"y" : @(frame.origin.y),
-            @"width" : @(frame.size.width),
-            @"height" : @(frame.size.height),
+            keys.x : @(frame.origin.x),
+            keys.y : @(frame.origin.y),
+            keys.width : @(frame.size.width),
+            keys.height : @(frame.size.height),
         }];
     }
     return rects;
@@ -49,12 +49,6 @@ ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *c
 
 @implementation ANNScreenRegions
 
-+ (void)initialize {
-    if (self == ANNScreenRegions.class) {
-        ANNScreenRegionsById = [NSMutableDictionary new];
-    }
-}
-
 + (NSDictionary<NSString *, NSArray *> *)regionsOfView:(UIView *)view
                                        inCoordinatesOf:(UIView *)coordinateView {
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
@@ -63,43 +57,14 @@ ANNRegionRects(NSArray<UIViewReservedRegion *> *regions, UIView *view, UIView *c
             [view reservedRegionsOfKind:[UIViewReservedRegionKind divisionRegionKind]];
         NSArray<UIViewReservedRegion *> *occlusion =
             [view reservedRegionsOfKind:[UIViewReservedRegionKind occlusionRegionKind]];
+        const auto &keys = ANNEventContract.ScreenRegionsChanged;
         return @{
-            @"division" : ANNRegionRects(division, view, coordinateView),
-            @"occlusion" : ANNRegionRects(occlusion, view, coordinateView),
+            keys.division : ANNRegionRects(division, view, coordinateView),
+            keys.occlusion : ANNRegionRects(occlusion, view, coordinateView),
         };
     }
 #endif
     return nil;
 }
 
-+ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
-       forScreenId:(NSString *)screenId
-      eventEmitter:(ANNEventEmitter *)eventEmitter {
-    @synchronized(ANNScreenRegionsById) {
-        if ([ANNScreenRegionsById[screenId] isEqualToDictionary:regions]) {
-            return;
-        }
-        ANNScreenRegionsById[screenId] = regions;
-    }
-    [eventEmitter sendScreenRegionsChanged:screenId regions:regions];
-}
-
-+ (NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId {
-    @synchronized(ANNScreenRegionsById) {
-        return ANNScreenRegionsById[screenId];
-    }
-}
-
-+ (void)removeScreenId:(NSString *)screenId {
-    @synchronized(ANNScreenRegionsById) {
-        [ANNScreenRegionsById removeObjectForKey:screenId];
-    }
-}
-
-+ (void)removeAll {
-    @synchronized(ANNScreenRegionsById) {
-        [ANNScreenRegionsById removeAllObjects];
-    }
-}
-
 @end

package/ios/Layouts/Screen/ANNScreenSafeArea.h

@@ -7,10 +7,6 @@ NS_ASSUME_NONNULL_BEGIN
 typedef struct {
     /// The screen is in a stack.
     BOOL inStack;
-    /// The screen's stack shows its toolbar.
-    BOOL stackShowsToolbar;
-    /// The bottom of the window's safe area: the home indicator.
-    CGFloat windowBottomSafeArea;
     /// The physical side of the iPhone Duo vertical bar (iOS 27.1): `UIRectEdgeLeft`, `UIRectEdgeRight`, or
     /// `UIRectEdgeNone` without one.
     UIRectEdge verticalBarSide;
@@ -27,11 +23,10 @@ FOUNDATION_EXPORT UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize
                                                       UIEdgeInsets safeArea);
 
 /// The padding the screen's safe area view keeps (`layout.safeAreaEdges`): the insets on the padded edges, 0 on the
-/// others. With `layout.safeAreaEdges` exactly those edges (an explicit `'top'` keeps the top under a large title too);
-/// without it every edge but: the top under a shown top bar (in a stack, under the top bar, `topBar.visible` not
-/// `false`) or with a large title that can show; the bottom when the bottom inset covers more than the window's home
-/// indicator (by over 0.5 pt), or in a stack with a toolbar and `topBar.hideOnScroll`; the side of the vertical bar
-/// unless `layout.drawBehindVerticalBar` or `layout.verticalBars` is `false`.
+/// others. With `layout.safeAreaEdges` exactly those edges, but the top under a large title that can show (in a stack,
+/// `topBar.visible` not `false`); without it every edge but: the top under a shown top bar (in a stack, under the top
+/// bar, `topBar.visible` not `false`) or with a large title that can show; the bottom, always; the side of the
+/// vertical bar unless `layout.drawBehindVerticalBar` or `layout.verticalBars` is `false`.
 FOUNDATION_EXPORT UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
                                                 ANNScreenPaddingContext context);
 

package/ios/Layouts/Screen/ANNScreenSafeArea.mm

@@ -1,9 +1,6 @@
 #import "ANNScreenSafeArea.h"
 #import "ANNScreenBars.h"
 
-// A bar at the bottom covers more than the home indicator when the bottom inset passes it by more than this.
-static const CGFloat ANNBottomBarThreshold = 0.5;
-
 CGRect ANNScreenRootFrame(CGRect bounds, UIEdgeInsets safeArea, BOOL fromTop, BOOL toBottom) {
     CGFloat top = fromTop ? 0 : safeArea.top;
     CGFloat bottom = toBottom ? CGRectGetHeight(bounds) : CGRectGetHeight(bounds) - safeArea.bottom;
@@ -20,31 +17,32 @@ UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize viewSize, UIEdgeIn
 
 UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
                               ANNScreenPaddingContext context) {
+    ANNTopBarOptions *topBar = options.topBar;
+    BOOL topBarShown = [topBar.visible withDefault:YES];
+    // Under a large title the list keeps its first rows clear of the bar itself. A padded top would follow the bar as
+    // it collapses and move the list with it, and UIKit, which collapses the title by the list's offset, would keep
+    // the small title hidden.
+    BOOL largeTitleShown = topBarShown && context.inStack && ANNLargeTitleCanShow(options);
     NSArray<NSString *> *edges = options.layout.safeAreaEdges;
     if (edges) {
-        // Exactly the edges given; unknown names count for nothing (`layout.safeAreaEdges`).
-        return UIEdgeInsetsMake([edges containsObject:@"top"] ? insets.top : 0,
+        // Exactly the edges given, but the top under a large title; unknown names count for nothing
+        // (`layout.safeAreaEdges`).
+        BOOL top = [edges containsObject:@"top"] && !largeTitleShown;
+        return UIEdgeInsetsMake(top ? insets.top : 0,
                                 [edges containsObject:@"left"] ? insets.left : 0,
                                 [edges containsObject:@"bottom"] ? insets.bottom : 0,
                                 [edges containsObject:@"right"] ? insets.right : 0);
     }
     UIEdgeInsets padding = insets;
-    ANNTopBarOptions *topBar = options.topBar;
-    BOOL topBarShown = [topBar.visible withDefault:YES];
     // A bar hidden for a while (`hideOnScroll`, `hideOnTap`, `hideOnKeyboard`) still counts as shown: only
     // `topBar.visible: false` gives the content its top back. A large title that can show takes the top too: the list
     // goes under the bar that collapses it.
-    if (topBarShown && context.inStack &&
-        (ANNScreenIsUnderTopBar(options) || ANNLargeTitleCanShow(options))) {
+    if (largeTitleShown || (topBarShown && context.inStack && ANNScreenIsUnderTopBar(options))) {
         padding.top = 0;
     }
-    // A bar at the bottom over the home indicator (a tab bar, a toolbar, the bottom search field of iOS 26): the list
-    // goes under it. A tab bar at the top on iPad adds nothing to the bottom. A toolbar that hides on scroll counts as
-    // there.
-    if (insets.bottom > context.windowBottomSafeArea + ANNBottomBarThreshold ||
-        (context.inStack && context.stackShowsToolbar && [topBar.hideOnScroll withDefault:NO])) {
-        padding.bottom = 0;
-    }
+    // The bottom is free: the content goes down to the bottom of the screen, under the home indicator and under a bar
+    // at the bottom, and a list keeps its last rows clear with `useSafeAreaInsets()`.
+    padding.bottom = 0;
     BOOL behindVerticalBar = [options.layout.drawBehindVerticalBar withDefault:YES] &&
                              [options.layout.verticalBars withDefault:YES];
     if (behindVerticalBar) {