@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/ios/Layouts/Screen/ANNNativeScreenContext.mm

@@ -0,0 +1,84 @@
+#import "ANNNativeScreenContext+Internal.h"
+#import "ANNErrorTexts.h"
+#import "ANNEventEmitter.h"
+#import "ANNNativeScreenCalls.h"
+#import <React/RCTUtils.h>
+
+@implementation ANNNativeScreenContext {
+    __weak ANNEventEmitter *_eventEmitter;
+}
+
+- (instancetype)initWithComponentId:(NSString *)componentId
+                              props:(NSDictionary *)props
+                          functions:(NSArray<NSString *> *)functions
+                       eventEmitter:(ANNEventEmitter *)eventEmitter {
+    if (self = [super init]) {
+        _componentId = [componentId copy];
+        _props = [props copy] ?: @{};
+        _functions = [NSSet setWithArray:functions ?: @[]];
+        _eventEmitter = eventEmitter;
+    }
+    return self;
+}
+
+- (void)applyUpdate:(NSDictionary *)update {
+    NSMutableDictionary *props = [_props mutableCopy];
+    NSDictionary *changed = update[@"props"];
+    if ([changed isKindOfClass:NSDictionary.class]) {
+        [props addEntriesFromDictionary:changed];
+    }
+    NSArray *removed = update[@"removed"];
+    if ([removed isKindOfClass:NSArray.class]) {
+        [props removeObjectsForKeys:removed];
+    }
+    _props = [props copy];
+    NSArray *functions = update[@"functions"];
+    if ([functions isKindOfClass:NSArray.class]) {
+        _functions = [NSSet setWithArray:functions];
+    }
+    if (_onPropsChange) {
+        _onPropsChange(_props);
+    }
+}
+
+- (void)call:(NSString *)function
+     arguments:(NSArray *)arguments
+    completion:(ANNNativeScreenCallCompletion)completion {
+    [self send:@"function" name:function arguments:arguments completion:completion];
+}
+
+- (void)navigate:(NSString *)command
+       arguments:(NSArray *)arguments
+      completion:(ANNNativeScreenCallCompletion)completion {
+    [self send:@"command" name:command arguments:arguments completion:completion];
+}
+
+// The call waits for its answer under its id; the event takes it to JS.
+- (void)send:(NSString *)kind
+          name:(NSString *)name
+     arguments:(NSArray *)arguments
+    completion:(ANNNativeScreenCallCompletion)completion {
+    RCTExecuteOnMainQueue(^{
+      NSString *callId = [ANNNativeScreenCalls addCall:name
+                                              ofScreen:self->_componentId
+                                            completion:completion];
+      ANNEventEmitter *eventEmitter = self->_eventEmitter;
+      // No emitter, or one of a JavaScript that went (a screen held for the reload's 2 s): nobody would answer, so the
+      // call fails at once.
+      if (!eventEmitter || !eventEmitter.isCurrent) {
+          [ANNNativeScreenCalls failCall:callId
+                                  reason:[ANNErrorTexts nativeCallNotRunning:name
+                                                                 componentId:self->_componentId]];
+          return;
+      }
+      [eventEmitter sendNativeScreenCall:@{
+          @"componentId" : self->_componentId,
+          @"callId" : callId,
+          @"kind" : kind,
+          @"name" : name,
+          @"args" : arguments ?: @[],
+      }];
+    });
+}
+
+@end

package/ios/Layouts/Screen/ANNPreviewInteraction.h

@@ -0,0 +1,38 @@
+#import <UIKit/UIKit.h>
+
+/**
+ * `preview` of a push (`usePreview`): a long press on the view shows the pushed screen as a
+ * preview, with its `preview.actions` as a menu; a tap on the preview commits it (UIKit's context
+ * menu, on every device and with a pointer on iPad).
+ */
+@interface ANNPreviewInteraction : NSObject <UIContextMenuInteractionDelegate>
+
+/**
+ * Previews `preview` from `view`, the component view with the tag `reactTag`, and replaces an earlier
+ * preview of the view. `commit` runs on a tap on the preview and returns whether it showed the
+ * screen; the preview goes then, as the push it stands for is done. `dismissed` runs once when the
+ * preview goes without being shown as a screen: replaced by another preview of the view, after
+ * Fabric gave the view to another component, or when `source`, the screen of the view, goes.
+ */
++ (void)attachPreview:(UIViewController *)preview
+               toView:(UIView *)view
+             reactTag:(NSInteger)reactTag
+               source:(UIViewController *)source
+               commit:(BOOL (^)(void))commit
+            dismissed:(void (^)(void))dismissed;
+
+/**
+ * Takes away the preview of the screen with the id `componentId`, as it goes any other way without
+ * being shown as a screen: `dismissed` runs. Returns NO when no preview of that screen is attached
+ * (a tap showed the screen, the preview went already, or it still looks for its view).
+ */
++ (BOOL)dismissPreviewOfScreen:(NSString *)componentId;
+
+/**
+ * After a reload: every preview goes, without `dismissed` (the new JavaScript never asked for it).
+ * Returns their screens, which still have running React views: the caller destroys them once React
+ * Native started the surfaces again.
+ */
++ (NSArray<UIViewController *> *)removeAllPreviewsAfterReload;
+
+@end

package/ios/Layouts/Screen/ANNPreviewInteraction.mm

@@ -0,0 +1,252 @@
+#import "ANNPreviewInteraction.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <objc/runtime.h>
+
+static const void *ANNPreviewInteractionKey = &ANNPreviewInteractionKey;
+
+// Every preview until it goes (detach), which destroys its screen: its React view stops first. Kept
+// by its view only, it would go with the view (after a reload React Native drops the views of the
+// old screens) and take its screen along, with the React view running.
+static NSMutableSet *ANNPreviews(void) {
+    static NSMutableSet *previews;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      previews = [NSMutableSet new];
+    });
+    return previews;
+}
+
+// Kept by the source screen: when the screen goes, its previews go too.
+@interface ANNPreviewSourceLifetime : NSObject
+@property(nonatomic, weak) ANNPreviewInteraction *interaction;
+@end
+
+@implementation ANNPreviewInteraction {
+    UIViewController *_preview;
+    NSInteger _reactTag;
+    BOOL (^_commit)(void);
+    void (^_dismissed)(void);
+    UIContextMenuInteraction *_interaction;
+}
+
++ (void)attachPreview:(UIViewController *)preview
+               toView:(UIView *)view
+             reactTag:(NSInteger)reactTag
+               source:(UIViewController *)source
+               commit:(BOOL (^)(void))commit
+            dismissed:(void (^)(void))dismissed {
+    if (!view || !preview) {
+        if (dismissed) {
+            dismissed();
+        }
+        return;
+    }
+    [objc_getAssociatedObject(view, ANNPreviewInteractionKey) detach];
+    ANNPreviewInteraction *previewInteraction = [ANNPreviewInteraction new];
+    previewInteraction->_preview = preview;
+    previewInteraction->_reactTag = reactTag;
+    previewInteraction->_commit = [commit copy];
+    previewInteraction->_dismissed = [dismissed copy];
+    previewInteraction->_interaction =
+        [[UIContextMenuInteraction alloc] initWithDelegate:previewInteraction];
+    [view addInteraction:previewInteraction->_interaction];
+    // The interaction keeps its delegate weakly: the view keeps it.
+    objc_setAssociatedObject(view, ANNPreviewInteractionKey, previewInteraction,
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    [ANNPreviews() addObject:previewInteraction];
+    if (source) {
+        ANNPreviewSourceLifetime *lifetime = [ANNPreviewSourceLifetime new];
+        lifetime.interaction = previewInteraction;
+        // One per preview: a screen can preview from several views.
+        objc_setAssociatedObject(source, (__bridge const void *)previewInteraction, lifetime,
+                                 OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+}
+
+// The previews of the JavaScript before a reload left the set with it: an id the new one counted again finds its own.
++ (BOOL)dismissPreviewOfScreen:(NSString *)componentId {
+    for (ANNPreviewInteraction *preview in ANNPreviews().allObjects) {
+        if ([preview->_preview.layoutInfo.componentId isEqualToString:componentId]) {
+            [preview detach];
+            return YES;
+        }
+    }
+    return NO;
+}
+
++ (NSArray<UIViewController *> *)removeAllPreviewsAfterReload {
+    NSMutableArray<UIViewController *> *screens = [NSMutableArray new];
+    for (ANNPreviewInteraction *preview in ANNPreviews().allObjects) {
+        if (preview->_preview) {
+            [screens addObject:preview->_preview];
+        }
+        preview->_dismissed = nil;
+        [preview detach];
+    }
+    return screens;
+}
+
+- (void)detach {
+    UIView *view = _interaction.view;
+    [view removeInteraction:_interaction];
+    // A tap's commit animation may still run: a preview that went, its screen destroyed and its push failed, is not
+    // pushed when the animation ends.
+    _commit = nil;
+    void (^dismissed)(void) = _dismissed;
+    _dismissed = nil;
+    if (dismissed) {
+        dismissed();
+    }
+    // Last: the preview may go now.
+    if (view && objc_getAssociatedObject(view, ANNPreviewInteractionKey) == self) {
+        objc_setAssociatedObject(view, ANNPreviewInteractionKey, nil,
+                                 OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+    [ANNPreviews() removeObject:self];
+}
+
+#pragma mark - UIContextMenuInteractionDelegate
+
+- (UIContextMenuConfiguration *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+                        configurationForMenuAtLocation:(CGPoint)location {
+    // Fabric recycles component views: a view that shows another component has another tag now.
+    // A preview already shown as a screen is no preview any more.
+    if (interaction.view.tag != _reactTag || _preview.parentViewController ||
+        _preview.presentingViewController) {
+        [self detach];
+        return nil;
+    }
+    UIViewController *preview = _preview;
+    NSArray *actions = preview.resolveOptions.preview.actions;
+    return [UIContextMenuConfiguration
+        configurationWithIdentifier:nil
+                    previewProvider:^UIViewController * {
+                      return preview;
+                    }
+                     actionProvider:^UIMenu *(NSArray<UIMenuElement *> *suggestedActions) {
+                       return [UIMenu menuWithTitle:@""
+                                           children:[self menuElementsOf:actions preview:preview]];
+                     }];
+}
+
+- (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+    willPerformPreviewActionForMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
+                                            animator:(id<UIContextMenuInteractionCommitAnimating>)
+                                                         animator {
+    BOOL commit = [_preview.resolveOptionsWithDefault.preview.commit withDefault:NO];
+    // With `commit` the preview grows into the screen; without it, it goes away.
+    animator.preferredCommitStyle =
+        commit ? UIContextMenuInteractionCommitStylePop : UIContextMenuInteractionCommitStyleDismiss;
+    [animator addCompletion:^{
+      if (self->_commit && self->_commit()) {
+          // Shown as a screen: the push is done, nothing was dismissed.
+          self->_dismissed = nil;
+          [self detach];
+      }
+    }];
+}
+
+#pragma mark - Targeted previews
+
+// The view the menu lifts from and goes back to: a snapshot of the source view in its window. With
+// the source view itself UIKit adds its views next to it, among the React views of its parent, and
+// Fabric then mounts and unmounts at the wrong places.
+- (UITargetedPreview *)snapshotPreviewOf:(UIView *)view {
+    UIWindow *window = view.window;
+    UIView *snapshot = [view snapshotViewAfterScreenUpdates:NO];
+    if (!window || !snapshot) {
+        return nil;
+    }
+    UIPreviewParameters *parameters = [UIPreviewParameters new];
+    parameters.backgroundColor = UIColor.clearColor;
+    parameters.visiblePath = [UIBezierPath bezierPathWithRoundedRect:view.bounds
+                                                        cornerRadius:view.layer.cornerRadius];
+    CGPoint center = [view convertPoint:CGPointMake(CGRectGetMidX(view.bounds),
+                                                    CGRectGetMidY(view.bounds))
+                                 toView:window];
+    UIPreviewTarget *target = [[UIPreviewTarget alloc] initWithContainer:window center:center];
+    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters target:target];
+}
+
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+                                configuration:(UIContextMenuConfiguration *)configuration
+        highlightPreviewForItemWithIdentifier:(id<NSCopying>)identifier API_AVAILABLE(ios(16.0)) {
+    return [self snapshotPreviewOf:interaction.view];
+}
+
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+                                configuration:(UIContextMenuConfiguration *)configuration
+        dismissalPreviewForItemWithIdentifier:(id<NSCopying>)identifier API_AVAILABLE(ios(16.0)) {
+    return [self snapshotPreviewOf:interaction.view];
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
+// iOS 15.
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+    previewForHighlightingMenuWithConfiguration:(UIContextMenuConfiguration *)configuration {
+    return [self snapshotPreviewOf:interaction.view];
+}
+
+- (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+    previewForDismissingMenuWithConfiguration:(UIContextMenuConfiguration *)configuration {
+    return [self snapshotPreviewOf:interaction.view];
+}
+#pragma clang diagnostic pop
+
+#pragma mark - Actions
+
+// `preview.actions` of the previewed screen: `actions` of an action make a submenu, `style`
+// 'destructive' a red item and 'selected' a checked one. A press sends navigationButtonPressed
+// for the previewed screen with the id of the action.
+- (NSArray<UIMenuElement *> *)menuElementsOf:(NSArray *)actions preview:(UIViewController *)preview {
+    NSMutableArray<UIMenuElement *> *elements = [NSMutableArray new];
+    for (NSDictionary *action in actions) {
+        if (![action isKindOfClass:NSDictionary.class]) {
+            continue;
+        }
+        NSString *title = [action[@"title"] isKindOfClass:NSString.class] ? action[@"title"] : @"";
+        NSArray *subactions = [action[@"actions"] isKindOfClass:NSArray.class] ? action[@"actions"] : nil;
+        if (subactions.count > 0) {
+            [elements addObject:[UIMenu menuWithTitle:title
+                                             children:[self menuElementsOf:subactions
+                                                                   preview:preview]]];
+            continue;
+        }
+        NSString *actionId = action[@"id"];
+        __weak UIViewController *weakPreview = preview;
+        UIAction *item = [UIAction actionWithTitle:title
+                                             image:nil
+                                        identifier:nil
+                                           handler:^(__kindof UIAction *_Nonnull menuAction) {
+                                             UIViewController *previewed = weakPreview;
+                                             [previewed.eventEmitter
+                                                 sendOnNavigationButtonPressed:previewed.layoutInfo
+                                                                                   .componentId
+                                                                      buttonId:actionId];
+                                           }];
+        if ([action[@"style"] isEqual:@"destructive"]) {
+            item.attributes = UIMenuElementAttributesDestructive;
+        } else if ([action[@"style"] isEqual:@"selected"]) {
+            item.state = UIMenuElementStateOn;
+        }
+        [elements addObject:item];
+    }
+    return elements;
+}
+
+@end
+
+@implementation ANNPreviewSourceLifetime
+
+- (void)dealloc {
+    ANNPreviewInteraction *interaction = self.interaction;
+    if (!interaction) {
+        return;
+    }
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [interaction detach];
+    });
+}
+
+@end

package/ios/Layouts/Screen/ANNScreenBars.h

@@ -0,0 +1,29 @@
+#import "ANNNavigationOptions.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The one rule of where a screen sits against the bars (in one place) and the one check of the large title: pure
+/// functions of a screen's resolved options (its own over those of its stack, tabs and side menu, then the defaults).
+/// Every place that decides by these asks here.
+
+/// `topBar.largeTitle.displayMode` as UIKit gets it: `displayMode` decides over `visible` (`true` is `always`, `false`
+/// and unset are `never`); `inline` before iOS 17 is `always`. One of `always`, `never`, `automatic`, `inline`.
+FOUNDATION_EXPORT NSString *ANNLargeTitleDisplayMode(ANNNavigationOptions *options);
+
+/// A large title can show: its display mode isn't `never`.
+FOUNDATION_EXPORT BOOL ANNLargeTitleCanShow(ANNNavigationOptions *options);
+
+/// The screen goes under the top bar when any of these holds: `topBar.drawBehind`, `topBar.background.translucent`,
+/// `topBar.visible: false`, a large title can show, `topBar.hideOnScroll`, `topBar.searchBar.hideOnScroll`. An explicit
+/// `drawBehind: false` keeps none of the others out.
+FOUNDATION_EXPORT BOOL ANNScreenIsUnderTopBar(ANNNavigationOptions *options);
+
+/// The screen goes under the tab bar when any of these holds: `bottomTabs.drawBehind` (YES by default with the glass bar
+/// of iOS 26, NO before and in the compatibility mode), `bottomTabs.translucent`, `bottomTabs.visible: false`.
+FOUNDATION_EXPORT BOOL ANNScreenIsUnderTabBar(ANNNavigationOptions *options);
+
+/// Whether `options` (a merge) sets any key the rule reads: the screen applies the rule again then.
+FOUNDATION_EXPORT BOOL ANNOptionsChangeScreenBars(ANNNavigationOptions *options);
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenBars.mm

@@ -0,0 +1,47 @@
+#import "ANNScreenBars.h"
+#import "ANNTabsDesign.h"
+#import <UIKit/UIKit.h>
+
+NSString *ANNLargeTitleDisplayMode(ANNNavigationOptions *options) {
+    ANNTopBarLargeTitleOptions *largeTitle = options.topBar.largeTitle;
+    NSString *mode = largeTitle.displayMode.hasValue ? [largeTitle.displayMode get] : nil;
+    if (mode.length == 0) {
+        return [largeTitle.visible withDefault:NO] ? @"always" : @"never";
+    }
+    if ([mode isEqualToString:@"inline"]) {
+        if (@available(iOS 17.0, *)) {
+            return mode;
+        }
+        return @"always";
+    }
+    return mode;
+}
+
+BOOL ANNLargeTitleCanShow(ANNNavigationOptions *options) {
+    return ![ANNLargeTitleDisplayMode(options) isEqualToString:@"never"];
+}
+
+BOOL ANNScreenIsUnderTopBar(ANNNavigationOptions *options) {
+    ANNTopBarOptions *topBar = options.topBar;
+    return [topBar.drawBehind withDefault:NO] || [topBar.background.translucent withDefault:NO] ||
+           ![topBar.visible withDefault:YES] || ANNLargeTitleCanShow(options) ||
+           [topBar.hideOnScroll withDefault:NO] || [topBar.searchBar.hideOnScroll withDefault:NO];
+}
+
+BOOL ANNScreenIsUnderTabBar(ANNNavigationOptions *options) {
+    ANNBottomTabsOptions *bottomTabs = options.bottomTabs;
+    // Under the glass bar by default; the compatibility mode keeps the opaque bar of before iOS 26.
+    BOOL drawsBehindByDefault = ANNTabsDesign.isGlass;
+    return [bottomTabs.drawBehind withDefault:drawsBehindByDefault] ||
+           [bottomTabs.translucent withDefault:NO] || ![bottomTabs.visible withDefault:YES];
+}
+
+BOOL ANNOptionsChangeScreenBars(ANNNavigationOptions *options) {
+    ANNTopBarOptions *topBar = options.topBar;
+    ANNBottomTabsOptions *bottomTabs = options.bottomTabs;
+    return topBar.drawBehind.hasValue || topBar.background.translucent.hasValue ||
+           topBar.visible.hasValue || topBar.largeTitle.displayMode.hasValue ||
+           topBar.largeTitle.visible.hasValue || topBar.hideOnScroll.hasValue ||
+           topBar.searchBar.hideOnScroll.hasValue || bottomTabs.drawBehind.hasValue ||
+           bottomTabs.translucent.hasValue || bottomTabs.visible.hasValue;
+}

package/ios/Layouts/Screen/ANNScreenInsets.h

@@ -0,0 +1,30 @@
+#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

@@ -0,0 +1,68 @@
+#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/Screen/ANNScreenReadiness.h

@@ -0,0 +1,92 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What the safe area view of a screen said about its content.
+typedef NS_ENUM(NSInteger, ANNContentRendered) {
+    /// No safe area view ever spoke for the id (a screen of the old API): its root's children decide.
+    ANNContentRenderedUnknown,
+    /// The screen has a safe area view, and its content didn't render into it yet.
+    ANNContentRenderedNo,
+    /// The content rendered into the screen's safe area view (also when it rendered nothing, `null`); for good.
+    ANNContentRenderedYes,
+};
+
+/// Who waits for the signals of one id: the content of a screen or of a component (`ANNReactView`).
+@protocol ANNScreenReadinessListener <NSObject>
+
+@optional
+
+/// The safe area view of the id is laid out in its place, with a size. Once per id.
+- (void)screenReadinessDidLayOut:(NSString *)screenId;
+
+/// The content of the id rendered into its safe area view. Once per id.
+- (void)screenReadinessContentDidRender:(NSString *)screenId;
+
+@end
+
+/// Where the safe area view of a screen tells the screen's container that the screen is ready, by the screen's id: "it
+/// has a safe area view", "laid out" and "content rendered". The core waits for these, with no search through the views
+/// and no filter of React Native's shared notifications. The signals are sticky: the listener of an id hears each once,
+/// at the signal or as it starts to listen. Main queue.
+@interface ANNScreenReadiness : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+#pragma mark - What the safe area view asks and says
+
+/// Whether the screen or component with this id waits to be laid out in its place before it renders: YES unless the
+/// core marked the id as one that renders at once.
++ (BOOL)screenWaitsForReadiness:(NSString *)screenId;
+
+/// The screen of this id has a safe area view: its content's readiness comes from it, never from its root's
+/// children. The safe area view says it as its `screenId` arrives.
++ (void)screenHasSafeAreaView:(NSString *)screenId;
+
+/// The safe area view of the screen is laid out in its place, with a size.
++ (void)screenDidLayOut:(NSString *)screenId;
+
+/// The screen rendered into its safe area view, also when it rendered nothing (`null`).
++ (void)screenContentDidRender:(NSString *)screenId;
+
+#pragma mark - What the core asks and marks
+
+/// A root the core made that renders at once: the React root of a component of a bar (title, button, background),
+/// of a tab item, of the tabs' accessory. Its content view marks it at its init and unmarks it at its stop. A screen
+/// and the results component of a search are never marked.
++ (void)setRendersAtOnce:(BOOL)rendersAtOnce forScreenId:(NSString *)screenId;
+
+/// Whether the safe area view of the id was laid out.
++ (BOOL)isLaidOut:(NSString *)screenId;
+
+/// What the safe area view of the id said about its content.
++ (ANNContentRendered)contentRenderedOfScreen:(NSString *)screenId;
+
+/// The one listener of the id (held weakly). A signal given already reaches it at once. An id marked "renders at once"
+/// (a component of a bar, which several screens may show with one id) keeps every live listener instead: a new one
+/// leaves the others theirs, gets what was said before only when it is the id's only listener, and every later signal
+/// of the id reaches all of them, each deciding by its own mount whether the signal is its own.
++ (void)setListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId;
+
+/// Removes `listener` if it is the one of the id (or one of an id that renders at once): a later screen with the same
+/// id keeps its own.
++ (void)removeListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId;
+
+/// Whether `listener` is the one of the id now (or one of them, for an id that renders at once).
++ (BOOL)isListener:(id<ANNScreenReadinessListener>)listener forScreenId:(NSString *)screenId;
+
+/// How many live listeners the id has.
++ (NSUInteger)listenerCountForScreenId:(NSString *)screenId;
+
+/// The screen of the id is destroyed and no other node has the id, a root that renders at once stops while it still
+/// holds the id, or a new root of the id starts: what the safe area view of the id said goes.
++ (void)removeScreenId:(NSString *)screenId;
+
+/// The JavaScript reloaded: everything goes before the new JavaScript renders. It counts its ids anew, and a sticky
+/// "rendered" of an old screen would make the new screen with the same id ready at once.
++ (void)reset;
+
+@end
+
+NS_ASSUME_NONNULL_END