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

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -1,6 +1,5 @@
 #import "ANNComponentViewController.h"
 #import "ANNAppearanceDispatcher.h"
-#import "ANNArrangementState.h"
 #import "ANNBottomTabsController.h"
 #import "ANNComponentPresenter.h"
 #import "ANNHinge.h"
@@ -10,18 +9,22 @@
 #import "ANNPendingLayers.h"
 #import "ANNPreviewPush.h"
 #import "ANNScreenBars.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
 #import "ANNScreenRegions.h"
 #import "ANNScreenSafeArea.h"
+#import "ANNScreenSettling.h"
 #import "ANNStackController.h"
+#import "ANNSurfaceHostingView.h"
 #import "ANNSystemUI.h"
 #import "ANNTopBarPresenter.h"
 #import "ANNUtils.h"
 
 @implementation ANNComponentViewController {
-    // Where the content is lent while it mounts unseen (the tabs' preload window).
-    __weak UIView *_contentLentTo;
+    // What the screen would send while the geometry settles (`ANNScreenSettling`), and whether it still owes it.
+    UIEdgeInsets _settlingInsets;
+    UIEdgeInsets _settlingPadding;
+    BOOL _settlingHeld;
 }
 
 - (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
@@ -46,8 +49,8 @@
                           defaultOptions:defaultOptions
                                presenter:presenter
                             eventEmitter:eventEmitter];
-    // While the screen lives (removed at its destroy): the end of an edit gives the key commands back, and a change of
-    // the hinge's state moves the regions without a change of size or traits.
+    // While the screen lives (removed at its destroy): the end of an edit gives the key commands back, a change of the
+    // hinge's state moves the regions without a change of size or traits, and the end of a fold sends the insets.
     NSNotificationCenter *center = NSNotificationCenter.defaultCenter;
     [center addObserver:self
                selector:@selector(textDidEndEditing:)
@@ -61,11 +64,21 @@
                selector:@selector(hingeDidChange:)
                    name:ANNHingeDidChangeNotification
                  object:nil];
+    [center addObserver:self
+               selector:@selector(screenSettlingDidEnd:)
+                   name:ANNScreenSettlingDidEndNotification
+                 object:nil];
     return self;
 }
 
 #pragma mark - The view
 
+- (nullable ANNComponentPresenter *)componentPresenter {
+    ANNNodePresenter *presenter = self.presenter;
+    return [presenter isKindOfClass:ANNComponentPresenter.class] ? (ANNComponentPresenter *)presenter
+                                                                  : nil;
+}
+
 // The size of the screen of the navigation window's scene, not the deprecated main screen: a surface made before the
 // screen is in a window starts with the width it will have.
 - (void)loadView {
@@ -94,6 +107,26 @@
     }
     // The pair the screen is in may lie otherwise now.
     [self.arrangement screenDidChangeLayout:self];
+    [self.componentPresenter layOutStatusBarBlur];
+}
+
+// UIKit names the size transition as the moment the status bar's frame changes (a rotation, a new window size): the
+// blur follows it along the animation and takes the final frame at its end. The React content takes its new size
+// without animation meanwhile, or what it draws itself is stretched along the animation (`ANNSurfaceHostingView`). On
+// a device with a hinge the insets wait until the geometry settles.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    [ANNScreenSettling beginWithTransition:coordinator];
+    [ANNSurfaceHostingView followSizeTransition:coordinator];
+    __weak ANNComponentViewController *weakSelf = self;
+    [coordinator
+        animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf.componentPresenter layOutStatusBarBlur];
+        }
+        completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          [weakSelf.componentPresenter layOutStatusBarBlur];
+        }];
 }
 
 - (void)viewSafeAreaInsetsDidChange {
@@ -102,14 +135,26 @@
 }
 
 // The regions UIKit reserves are still the old ones while it tells of new traits: they are read again on the next turn
-// of the main queue. A fold changes the traits, not always the size.
+// of the main queue. A fold changes the traits, not always the size; a new edge of the vertical bar comes before the
+// safe area that goes with it, so the insets wait until the geometry settles.
 - (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection {
     [super traitCollectionDidChange:previousTraitCollection];
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+    if (@available(iOS 27.1, *)) {
+        // A screen that comes into the window gets the bar's edge from none: that is no fold.
+        UIVerticalBarEdge before = previousTraitCollection.verticalBarEdge;
+        if (self.viewIfLoaded.window && before != UIVerticalBarEdgeUnspecified &&
+            before != self.traitCollection.verticalBarEdge) {
+            [ANNScreenSettling beginForTraitChange];
+        }
+    }
+#endif
     [self updateRootLayout];
     [self.arrangement screenDidChangeLayout:self];
     __weak ANNComponentViewController *weakSelf = self;
     dispatch_async(dispatch_get_main_queue(), ^{
       [weakSelf updateRootLayout];
+      [weakSelf.componentPresenter layOutStatusBarBlur];
     });
 }
 
@@ -119,10 +164,17 @@
 // hide. They are the screen's report as a container gives it; the dispatcher keeps it to one per appearance. While a
 // command drives the appearance (a window's root replaced), UIKit's calls come at its own moments and would break the
 // command's order: the command reports instead.
+// A screen that left the window while the geometry settled sends what it held as it comes back: the end of the settling
+// found it out of the window.
+- (void)viewIsAppearing:(BOOL)animated {
+    [super viewIsAppearing:animated];
+    if (_settlingHeld && !ANNScreenSettling.isSettling) {
+        [self updateRootLayout];
+    }
+}
+
 - (void)viewWillAppear:(BOOL)animated {
     [super viewWillAppear:animated];
-    // A tab shows for the first time while its content still mounts in the preload window.
-    [self takeContentBack];
     // A preview screen that UIKit's menu takes leaves its unseen place first, so that the menu reports it.
     [ANNPreviewPush screenWillAppear:self];
     if (![ANNAppearanceDispatcher isAppearanceDriven:self]) {
@@ -138,6 +190,12 @@
     [ANNSystemUI setNeedsUpdate];
     [self.arrangement screenDidChangeLayout:self];
     [ANNHinge watchForScreens];
+    // A parked screen whose place gave it no safe area at all lays out with its view's own from now on.
+    if (self.placeWhileParked && ![ANNParking isUnseen:self]) {
+        self.placeWhileParked = nil;
+        self.placeKeptUntilAppearance = NO;
+        [self updateRootLayout];
+    }
     // Once JavaScript heard the appearance (a driven one ends later, with its command).
     __weak ANNComponentViewController *weakSelf = self;
     [ANNAppearanceDispatcher afterDidAppearOf:self.appearance
@@ -200,9 +258,7 @@
 #pragma mark - The root frame and the safe area
 
 - (void)applyBackground {
-    if ([self.presenter isKindOfClass:ANNComponentPresenter.class]) {
-        [(ANNComponentPresenter *)self.presenter applyBackground:[self resolveOptionsWithDefault]];
-    }
+    [self.componentPresenter applyBackground:[self resolveOptionsWithDefault]];
 }
 
 // The navigation controller that shows the screen's stack: the stack, or UIKit's More navigation while a tab of More
@@ -341,11 +397,32 @@
 }
 #endif
 
+// The place the screen waits to show in, while it is parked out of it and until UIKit gives it a safe area of its
+// own there: the push lays the screen out once before that, with none, and a list laid out then at the screen's top
+// would stay the list the bar follows. A place that shows with no safe area at all hands over as the screen appears.
+- (nullable ANNScreenPlace *)parkedPlace {
+    ANNScreenPlace * (^place)(void) = self.placeWhileParked;
+    if (!place) {
+        return nil;
+    }
+    if (!self.placeKeptUntilAppearance && ![ANNParking isUnseen:self] &&
+        self.parentViewController &&
+        !UIEdgeInsetsEqualToEdgeInsets(self.view.safeAreaInsets, UIEdgeInsetsZero)) {
+        self.placeWhileParked = nil;
+        return nil;
+    }
+    return place();
+}
+
 - (CGRect)rootFrameForOptions:(ANNNavigationOptions *)options {
     UIView *view = self.view;
-    BOOL fromTop = ANNScreenIsUnderTopBar(options) || ![self hasShownTopBar];
-    BOOL toBottom = ANNScreenIsUnderTabBar(options) || ![self hasShownTabBar];
-    return ANNScreenRootFrame(view.bounds, view.safeAreaInsets, fromTop, toBottom);
+    ANNScreenPlace *place = [self parkedPlace];
+    BOOL topBarShown = place ? place.showsTopBar : [self hasShownTopBar];
+    BOOL tabBarShown = place ? place.showsTabBar : [self hasShownTabBar];
+    BOOL fromTop = ANNScreenIsUnderTopBar(options) || !topBarShown;
+    BOOL toBottom = ANNScreenIsUnderTabBar(options) || !tabBarShown;
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    return ANNScreenRootFrame(view.bounds, safeArea, fromTop, toBottom);
 }
 
 - (void)updateRootLayout {
@@ -354,7 +431,7 @@
     }
     ANNNavigationOptions *options = [self resolveOptionsWithDefault];
     UIView<ANNComponentProtocol> *content = _reactView;
-    if (content && !self.contentIsLent) {
+    if (content) {
         CGRect frame = [self rootFrameForOptions:options];
         if (!CGRectEqualToRect(content.frame, frame)) {
             content.frame = frame;
@@ -385,10 +462,12 @@
     return UIRectEdgeNone;
 }
 
-// The insets and the padding of a React screen or a slot screen go to the module, which keeps them, gives JavaScript
+// The insets and the padding of a React screen or a slot screen go to the store, which keeps them, gives JavaScript
 // what still covers the content and tells only of changes; the regions in the same pass. Only in a window and with an
 // id; never after the destroy, which removed them (a late layout would bring them back), nor for the JavaScript that
-// went (an old screen held after a reload: the new JavaScript may give its id to a new screen).
+// went (an old screen held after a reload: the new JavaScript may give its id to a new screen). While the geometry
+// settles they are only noted, the steps of a fold would reach JavaScript one by one; but a screen's first values go at
+// once, since JavaScript reads them as it renders the screen.
 - (void)updateSafeAreaWithOptions:(ANNNavigationOptions *)options {
     UIView<ANNComponentProtocol> *content = _reactView;
     NSString *componentId = self.layoutInfo.componentId;
@@ -399,28 +478,41 @@
         self.nodeHelper.destroyed) {
         return;
     }
-    UIEdgeInsets insets =
-        ANNScreenInsetsOverRoot(content.frame, view.bounds.size, view.safeAreaInsets);
+    // A parked screen has no safe area of its own: it takes its place's.
+    ANNScreenPlace *place = [self parkedPlace];
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    UIEdgeInsets insets = ANNScreenInsetsOverRoot(content.frame, view.bounds.size, safeArea);
     UINavigationController *stack = [self shownNavigation];
     ANNScreenPaddingContext context = {
         .inStack = stack != nil,
-        // The stack's toolbar, by the rule the stack shows it with: one that `topBar.hideOnScroll`
-        // hid with the bar still counts.
-        .stackShowsToolbar = stack != nil && options.toolbar.shouldShow,
-        .windowBottomSafeArea = window.safeAreaInsets.bottom,
         .verticalBarSide = [self verticalBarSide],
     };
     UIEdgeInsets padding = ANNScreenPadding(insets, options, context);
-    [ANNScreenInsets setInsets:insets
-                       padding:padding
-                   forScreenId:componentId
-                  eventEmitter:eventEmitter];
+    if (ANNScreenSettling.isSettling && [ANNScreenEnvironment insetsForScreenId:componentId]) {
+        if (!UIEdgeInsetsEqualToEdgeInsets(insets, _settlingInsets) ||
+            !UIEdgeInsetsEqualToEdgeInsets(padding, _settlingPadding)) {
+            _settlingInsets = insets;
+            _settlingPadding = padding;
+            [ANNScreenSettling valuesDidChange];
+        }
+        _settlingHeld = YES;
+        return;
+    }
+    _settlingHeld = NO;
+    [ANNScreenEnvironment setInsets:insets
+                            padding:padding
+                        forScreenId:componentId
+                       eventEmitter:eventEmitter];
     [self updateRegions];
 }
 
-// The regions in the same pass, and on the next turn after a change of the hinge's state (`hingeDidChange:`). Nil
-// before iOS 27.1: nothing to keep. An empty first result is not sent.
+// The regions in the same pass, and on the next turn after a change of the hinge's state (`hingeDidChange:`); not while
+// the geometry settles, whose end sends them with the insets. Nil before iOS 27.1: nothing to keep. The store neither
+// keeps nor sends an empty first result.
 - (void)updateRegions {
+    if (ANNScreenSettling.isSettling) {
+        return;
+    }
     UIView<ANNComponentProtocol> *content = _reactView;
     NSString *componentId = self.layoutInfo.componentId;
     ANNEventEmitter *eventEmitter = self.eventEmitter;
@@ -434,11 +526,11 @@
     if (!regions) {
         return;
     }
-    BOOL empty = [regions[@"division"] count] == 0 && [regions[@"occlusion"] count] == 0;
-    if (empty && ![ANNScreenRegions regionsForScreenId:componentId]) {
-        return;
-    }
-    [ANNScreenRegions setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
+    [ANNScreenEnvironment setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
+}
+
+- (void)screenSettlingDidEnd:(NSNotification *)notification {
+    [self updateRootLayout];
 }
 
 - (void)hingeDidChange:(NSNotification *)notification {
@@ -511,37 +603,6 @@
     });
 }
 
-#pragma mark - The preload window
-
-- (BOOL)contentIsLent {
-    return _contentLentTo != nil;
-}
-
-- (BOOL)lendContentTo:(UIView *)host {
-    UIView<ANNComponentProtocol> *content = _reactView;
-    if (!content || _contentLentTo || content.window || self.nodeHelper.destroyed ||
-        ![content isKindOfClass:ANNReactView.class]) {
-        return NO;
-    }
-    _contentLentTo = host;
-    [host addSubview:content];
-    return YES;
-}
-
-- (void)takeContentBack {
-    if (!_contentLentTo) {
-        return;
-    }
-    _contentLentTo = nil;
-    UIView<ANNComponentProtocol> *content = _reactView;
-    if (!content || self.nodeHelper.destroyed) {
-        [content removeFromSuperview];
-        return;
-    }
-    [self.view insertSubview:content atIndex:0];
-    [self updateRootLayout];
-}
-
 #pragma mark - Leaving
 
 - (void)screenWillLeave {
@@ -606,9 +667,7 @@
     content.autoresizingMask = UIViewAutoresizingNone;
     content.frame = [self rootFrameForOptions:[self resolveOptionsWithDefault]];
     [view addSubview:content];
-    if ([self.presenter isKindOfClass:ANNComponentPresenter.class]) {
-        [(ANNComponentPresenter *)self.presenter keepStatusBarBlurOnTop];
-    }
+    [self.componentPresenter keepStatusBarBlurOnTop];
     [self applyBackground];
     [self updateRootLayout];
 }
@@ -634,17 +693,13 @@
     [topBar releaseLists];
     [topBar stopComponents];
     [self destroyReactView];
-    // The stop holds the hosting view until the surface stopped: the screen lets go of its content view now, wherever
-    // it is (a preload window too).
-    _contentLentTo = nil;
+    // The stop holds the hosting view until the surface stopped: the screen lets go of its content view now.
     [_reactView removeFromSuperview];
     // The data is kept by id: a node that holds the id now (a new JavaScript reused it while this screen waited for
     // its destroy, as at a reload) keeps it.
     NSString *componentId = self.layoutInfo.componentId;
     if (componentId && ![ANNNodeRegistry nodeForComponentId:componentId]) {
-        [ANNScreenInsets removeScreenId:componentId];
-        [ANNScreenRegions removeScreenId:componentId];
-        [ANNArrangementState removeScreenId:componentId];
+        [ANNScreenEnvironment removeScreenId:componentId];
         [ANNScreenReadiness removeScreenId:componentId];
     }
 }

package/ios/Layouts/Screen/ANNNativeScreenContext.mm

@@ -1,5 +1,6 @@
 #import "ANNNativeScreenContext+Internal.h"
 #import "ANNErrorTexts.h"
+#import "ANNEventContract.h"
 #import "ANNEventEmitter.h"
 #import "ANNNativeScreenCalls.h"
 #import <React/RCTUtils.h>
@@ -71,12 +72,13 @@
                                                                  componentId:self->_componentId]];
           return;
       }
+      const auto &keys = ANNEventContract.NativeScreenCall;
       [eventEmitter sendNativeScreenCall:@{
-          @"componentId" : self->_componentId,
-          @"callId" : callId,
-          @"kind" : kind,
-          @"name" : name,
-          @"args" : arguments ?: @[],
+          keys.componentId : self->_componentId,
+          keys.callId : callId,
+          keys.kind : kind,
+          keys.name : name,
+          keys.args : arguments ?: @[],
       }];
     });
 }

package/ios/Layouts/Screen/ANNPreviewInteraction.h

@@ -9,15 +9,18 @@
 
 /**
  * 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.
+ * preview of the view. `prepare` runs as each press starts, before the menu shows the preview: it
+ * renders the screen if it hasn't yet, and returns NO when the preview went instead (no menu shows
+ * then). `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
+              prepare:(BOOL (^)(void))prepare
                commit:(BOOL (^)(void))commit
             dismissed:(void (^)(void))dismissed;
 

package/ios/Layouts/Screen/ANNPreviewInteraction.mm

@@ -24,15 +24,23 @@ static NSMutableSet *ANNPreviews(void) {
 @implementation ANNPreviewInteraction {
     UIViewController *_preview;
     NSInteger _reactTag;
+    __weak UIViewController *_source;
+    BOOL (^_prepare)(void);
     BOOL (^_commit)(void);
     void (^_dismissed)(void);
     UIContextMenuInteraction *_interaction;
+    // The snapshots of the view that the menu of this press lifts and puts back, over the view until
+    // the menu is gone. Each press has its own list: a new press may start while the last menu goes.
+    NSMutableArray<UIView *> *_snapshots;
+    // The list of the menu that goes now: its end removes them.
+    __weak NSMutableArray<UIView *> *_endingSnapshots;
 }
 
 + (void)attachPreview:(UIViewController *)preview
                toView:(UIView *)view
              reactTag:(NSInteger)reactTag
                source:(UIViewController *)source
+              prepare:(BOOL (^)(void))prepare
                commit:(BOOL (^)(void))commit
             dismissed:(void (^)(void))dismissed {
     if (!view || !preview) {
@@ -45,6 +53,8 @@ static NSMutableSet *ANNPreviews(void) {
     ANNPreviewInteraction *previewInteraction = [ANNPreviewInteraction new];
     previewInteraction->_preview = preview;
     previewInteraction->_reactTag = reactTag;
+    previewInteraction->_source = source;
+    previewInteraction->_prepare = [prepare copy];
     previewInteraction->_commit = [commit copy];
     previewInteraction->_dismissed = [dismissed copy];
     previewInteraction->_interaction =
@@ -91,7 +101,9 @@ static NSMutableSet *ANNPreviews(void) {
     [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.
+    _prepare = nil;
     _commit = nil;
+    [ANNPreviewInteraction removeSnapshots:_snapshots];
     void (^dismissed)(void) = _dismissed;
     _dismissed = nil;
     if (dismissed) {
@@ -116,6 +128,18 @@ static NSMutableSet *ANNPreviews(void) {
         [self detach];
         return nil;
     }
+    // UIKit ends a lift that never became a menu too (the touch ended before the long press); should
+    // it not, the snapshot of that press goes now.
+    if (_snapshots != _endingSnapshots) {
+        [ANNPreviewInteraction removeSnapshots:_snapshots];
+    }
+    _snapshots = [NSMutableArray new];
+    // UIKit asks for the configuration as the press starts, about half a second before it shows the preview: the
+    // screen renders now, so that its content is there by then.
+    if (_prepare && !_prepare()) {
+        [self detach];
+        return nil;
+    }
     UIViewController *preview = _preview;
     NSArray *actions = preview.resolveOptions.preview.actions;
     return [UIContextMenuConfiguration
@@ -129,6 +153,23 @@ static NSMutableSet *ANNPreviews(void) {
                      }];
 }
 
+// The menu goes: the snapshots of its press go once it is gone. UIKit asks for the one
+// it goes back to after this call, so the list is read at the end, not now.
+- (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+       willEndForConfiguration:(UIContextMenuConfiguration *)configuration
+                      animator:(id<UIContextMenuInteractionAnimating>)animator {
+    NSMutableArray<UIView *> *snapshots = _snapshots;
+    _endingSnapshots = snapshots;
+    void (^remove)(void) = ^{
+      [ANNPreviewInteraction removeSnapshots:snapshots];
+    };
+    if (animator) {
+        [animator addCompletion:remove];
+    } else {
+        dispatch_async(dispatch_get_main_queue(), remove);
+    }
+}
+
 - (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
     willPerformPreviewActionForMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
                                             animator:(id<UIContextMenuInteractionCommitAnimating>)
@@ -148,24 +189,45 @@ static NSMutableSet *ANNPreviews(void) {
 
 #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.
+// The view the menu lifts from and goes back to: a snapshot of the source view, laid over it in the
+// view of its screen, the core's own (in its window when the view is elsewhere), so that it goes with
+// the screen (a pop right after the menu). 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.
+// A snapshot out of the window, with only a target there, iOS 27 doesn't lift: it dims it in place.
 - (UITargetedPreview *)snapshotPreviewOf:(UIView *)view {
-    UIWindow *window = view.window;
+    UIView *container = _source.viewIfLoaded;
+    if (!container || ![view isDescendantOfView:container]) {
+        container = view.window;
+    }
+    // A screen out of its window (a command took it away while the menu showed) has no place for it:
+    // UIKit needs the view in a window.
+    if (!container.window) {
+        return nil;
+    }
     UIView *snapshot = [view snapshotViewAfterScreenUpdates:NO];
-    if (!window || !snapshot) {
+    if (!snapshot) {
         return nil;
     }
+    snapshot.frame = [view convertRect:view.bounds toView:container];
+    snapshot.userInteractionEnabled = NO;
+    snapshot.accessibilityElementsHidden = YES;
+    [container addSubview:snapshot];
+    if (!_snapshots) {
+        _snapshots = [NSMutableArray new];
+    }
+    [_snapshots addObject:snapshot];
     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];
+    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters];
+}
+
++ (void)removeSnapshots:(NSMutableArray<UIView *> *)snapshots {
+    for (UIView *snapshot in snapshots) {
+        [snapshot removeFromSuperview];
+    }
+    [snapshots removeAllObjects];
 }
 
 - (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction

package/ios/Layouts/Screen/ANNScreenEnvironment.h

@@ -0,0 +1,63 @@
+#import "ANNEventEmitter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// A view that keeps a screen's content out of its padding (the screen's safe area view).
+@protocol ANNScreenPaddingListener <NSObject>
+/// The padding of its screen changed. Main queue.
+- (void)screenPaddingDidChange;
+@end
+
+/// What JavaScript knows of each screen's place, by the screen's id, in one record: its safe area (the insets
+/// JavaScript gets, `useSafeAreaInsets`, and the padding of its safe area view), its reserved regions
+/// (`useReservedRegions`) and, in a pair, its arrangement (`useArrangement`). The core measures them
+/// (`ANNScreenSafeArea`, `ANNScreenRegions`, the pair's layout) on the main queue and keeps them here; JavaScript reads
+/// them from its own thread for a screen's first render, under one lock, and gets every change as an event. When the
+/// screen goes, `removeScreenId:` clears all of it. As on Android (`ScreenEnvironment`).
+@interface ANNScreenEnvironment : NSObject
+
+/// Keeps the screen's insets and the padding of its safe area view. The padding is the part of the insets the safe
+/// area view keeps the content out of (the edges the screen's options give); JavaScript gets the rest, what still
+/// covers the content (0 on a padded edge). Tells the padding's listeners of that screen when the padding changed, then
+/// JavaScript (`ANN.ScreenInsetsChanged`) when its insets did. Main queue.
++ (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. Any thread.
++ (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;
+
+/// Keeps the screen's regions (`{ division, occlusion }`) and tells JavaScript (`ANN.ScreenRegionsChanged`) when they
+/// changed. None at first is what JavaScript reads before the first layout: it is neither kept nor told. Main queue.
++ (void)setRegions:(NSDictionary<NSString *, NSArray *> *)regions
+       forScreenId:(NSString *)screenId
+      eventEmitter:(ANNEventEmitter *)eventEmitter;
+/// `{ division, occlusion }`, or nil before the screen's regions were first kept. Any thread.
++ (nullable NSDictionary<NSString *, NSArray *> *)regionsForScreenId:(NSString *)screenId;
+
+/// Keeps the screen's arrangement (`{ placement, layout, front, hidden }`) and tells JavaScript
+/// (`ANN.ArrangementChanged`) when it changed; nothing goes without an emitter. Main queue.
++ (void)setArrangement:(NSDictionary<NSString *, id> *)arrangement
+           forScreenId:(NSString *)screenId
+          eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
+/// The screen's arrangement, or nil for a screen outside a pair. Any thread.
++ (nullable NSDictionary<NSString *, id> *)arrangementForScreenId:(NSString *)screenId;
+
+/// Tells `listener` of each change of the screen's padding, until it is removed or goes (held weakly). Several
+/// listeners may listen to one screen. Main queue.
++ (void)addPaddingListener:(id<ANNScreenPaddingListener>)listener forScreenId:(NSString *)screenId;
++ (void)removePaddingListener:(id<ANNScreenPaddingListener>)listener
+                  forScreenId:(NSString *)screenId;
+
+/// Forgets everything kept for the screen. Its padding listeners stay: a live safe area view keeps listening while it
+/// keeps the id, and stops itself. Main queue.
++ (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