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

package/ios/Layouts/SplitView/ANNSplitViewController.h

@@ -0,0 +1,52 @@
+#import "ANNLayoutProtocol.h"
+#import "UIViewController+LayoutProtocol.h"
+#import "UINavigationController+ANNCommands.h"
+#import <UIKit/UIKit.h>
+
+/**
+ * `splitView`: a column-style UISplitViewController (iOS 14+) with its columns by name: `primary`
+ * (the layout's `master`), `secondary` (its `detail`), `supplementary` makes it three columns,
+ * `compact` is the layout of a compact width (iPhone) and `inspector` the inspector column
+ * (iPadOS 26). UIKit puts a column that is not a navigation controller (a stack) into one of its
+ * own, except the compact one.
+ */
+@interface ANNSplitViewController : UISplitViewController <ANNLayoutProtocol, UISplitViewControllerDelegate>
+
+/** The split view with the view controllers of its columns, by the name of the column. */
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+                           columns:(NSDictionary<NSString *, UIViewController *> *)columns;
+
+/**
+ * The view controller of the layout in a column: 'primary', 'supplementary', 'secondary',
+ * 'compact' or 'inspector'.
+ */
+- (UIViewController *)viewControllerOfColumn:(NSString *)column;
+
+/** Collapsed into the compact layout: UIKit shows no column then. */
+@property(nonatomic, readonly) BOOL isCollapsedIntoCompact;
+
+/**
+ * `showInColumn`: the screen goes in place of what the column ('secondary' or 'supplementary') shows: the screens of
+ * its stack, or the screen itself when the column is a screen alone. UIKit brings the column into view: a sidebar
+ * over it goes away; collapsed into one stack the column goes on top, with back to the columns before it.
+ */
+- (void)showScreen:(UIViewController *)screen
+              inColumn:(NSString *)column
+    fromViewController:(UIViewController *)fromViewController
+            completion:(ANNTransitionCompletionBlock)completion
+             rejection:(ANNTransitionRejectionBlock)rejection;
+
+/**
+ * `pop` of the only screen of the secondary or supplementary column's stack while the columns show as one stack
+ * (collapsed without a compact layout) and that column is on top: the column before it comes back, as the system back
+ * does (the supplementary one, else the primary), and `completion` runs once that is on screen. NO, with nothing done,
+ * when it doesn't apply.
+ */
+- (BOOL)goBackFromColumnOf:(UIViewController *)screen completion:(dispatch_block_t)completion;
+
+@end

package/ios/Layouts/SplitView/ANNSplitViewController.mm

@@ -0,0 +1,494 @@
+#import "ANNSplitViewController.h"
+#import "ANNErrorHandler.h"
+#import "ANNShownScreens.h"
+#import "UISplitViewController+ANNOptions.h"
+#import "UIViewController+LayoutProtocol.h"
+#import <React/RCTLog.h>
+
+// Every column a split view can have, in the order it gives them to UIKit and lists them as its children.
+static NSArray<NSString *> *ANNSplitViewColumnNames(void) {
+    return @[ @"primary", @"supplementary", @"secondary", @"compact", @"inspector" ];
+}
+
+static UISplitViewControllerColumn ANNSplitViewColumn(NSString *name) {
+    if ([name isEqualToString:@"supplementary"]) {
+        return UISplitViewControllerColumnSupplementary;
+    }
+    if ([name isEqualToString:@"secondary"]) {
+        return UISplitViewControllerColumnSecondary;
+    }
+    if ([name isEqualToString:@"compact"]) {
+        return UISplitViewControllerColumnCompact;
+    }
+    if ([name isEqualToString:@"inspector"]) {
+        if (@available(iOS 26.0, *)) {
+            return UISplitViewControllerColumnInspector;
+        }
+    }
+    return UISplitViewControllerColumnPrimary;
+}
+
+@implementation ANNSplitViewController {
+    NSDictionary<NSString *, UIViewController *> *_columns;
+    // The display mode and the inspector's state last sent to JS.
+    NSString *_sentDisplayModeState;
+    // Whether the columns show as one stack, as last sent to JS; nil before the first value.
+    NSNumber *_sentColumnsStacked;
+    BOOL _didAppear;
+    BOOL _laidOutInWindow;
+}
+
+// The initializer of `ANNLayoutProtocol`: the first two children are the `primary` and `secondary` columns.
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+              childViewControllers:(NSArray<UIViewController *> *)childViewControllers {
+    NSMutableDictionary *columns = [NSMutableDictionary new];
+    NSArray<NSString *> *names = @[ @"primary", @"secondary" ];
+    for (NSUInteger index = 0; index < MIN(childViewControllers.count, names.count); index++) {
+        columns[names[index]] = childViewControllers[index];
+    }
+    return [self initWithLayoutInfo:layoutInfo
+                            creator:creator
+                            options:options
+                     defaultOptions:defaultOptions
+                          presenter:presenter
+                       eventEmitter:eventEmitter
+                            columns:columns];
+}
+
+- (instancetype)initWithLayoutInfo:(ANNLayoutInfo *)layoutInfo
+                           creator:(id<ANNComponentViewCreator>)creator
+                           options:(ANNNavigationOptions *)options
+                    defaultOptions:(ANNNavigationOptions *)defaultOptions
+                         presenter:(ANNNodePresenter *)presenter
+                      eventEmitter:(ANNEventEmitter *)eventEmitter
+                           columns:(NSDictionary<NSString *, UIViewController *> *)columns {
+    // The style is given when the split view is made: three columns with a supplementary one.
+    self = [super initWithStyle:columns[@"supplementary"] ? UISplitViewControllerStyleTripleColumn
+                                                          : UISplitViewControllerStyleDoubleColumn];
+    NSMutableDictionary *usedColumns = [columns mutableCopy];
+    if (usedColumns[@"inspector"]) {
+        if (@available(iOS 26.0, *)) {
+        } else {
+            RCTLogWarn(@"[ApexNavigation] splitView.inspector needs iPadOS 26; it is left out.");
+            [usedColumns removeObjectForKey:@"inspector"];
+        }
+    }
+    _columns = [usedColumns copy];
+    self.options = options;
+    self.defaultOptions = defaultOptions;
+    self.layoutInfo = layoutInfo;
+    self.creator = creator;
+    self.eventEmitter = eventEmitter;
+    self.presenter = presenter;
+    for (NSString *name in ANNSplitViewColumnNames()) {
+        if (_columns[name]) {
+            [self setViewController:_columns[name] forColumn:ANNSplitViewColumn(name)];
+        }
+    }
+    self.delegate = self;
+    [presenter bindViewController:self];
+    self.extendedLayoutIncludesOpaqueBars = YES;
+    [presenter applyOptionsOnInit:self.resolveOptions];
+    return self;
+}
+
+// UIKit shows an inspector when the split view first appears; `inspector.visible` applies after it.
+- (void)viewDidAppear:(BOOL)animated {
+    [super viewDidAppear:animated];
+    if (!_didAppear) {
+        _didAppear = YES;
+        [self ann_setInspectorVisible:self.resolveOptionsWithDefault.splitView.inspector.visible
+                             animated:NO];
+    }
+}
+
+// UIKit collapses and expands the columns as the width changes, and lays them out again then. The first layout in a
+// window decides the columns UIKit shows: a layer that waits to show takes its screens again, and the system UI
+// follows the current child.
+- (void)viewDidLayoutSubviews {
+    [super viewDidLayoutSubviews];
+    [self sendColumnsStackedIfChanged];
+    if (!_laidOutInWindow && self.viewIfLoaded.window) {
+        _laidOutInWindow = YES;
+        [self shownColumnsChanged];
+    }
+}
+
+// What UIKit shows of the columns changed without an appearance below the split view to tell it.
+- (void)shownColumnsChanged {
+    [ANNShownScreens changedIn:self];
+}
+
+- (UIViewController *)viewControllerOfColumn:(NSString *)column {
+    return _columns[column];
+}
+
+- (BOOL)isCollapsedIntoCompact {
+    return self.isCollapsed && _columns[@"compact"] != nil;
+}
+
+// Collapsed without a compact layout, UIKit shows the columns as one stack: a column's navigation controller goes
+// over the one before it in the primary's stack.
+- (BOOL)columnsStacked {
+    return self.isCollapsed && !self.isCollapsedIntoCompact;
+}
+
+// UIKit takes a column off the one stack by itself (the back button, the edge swipe), whatever the column holds (a
+// stack, or a screen alone in a navigation controller of UIKit's own): the column under it shows, and its screen's
+// appearance at the end of UIKit's pop is the one call that reaches the split view. What it shows changed then.
+- (void)descendantDidAppear:(UIViewController *)screen {
+    if (self.columnsStacked) {
+        [ANNShownScreens changedIn:self];
+    }
+}
+
+// `ANN.SplitViewColumnsStacked`: the first value once the split view is in a window, then each change. JS keeps it by
+// the split view's id and takes the first value as a new start (a layout sent again with the same ids). Out of a
+// window nothing goes: a split view laid out before it shows, or one that has gone, would tell what nobody sees.
+- (void)sendColumnsStackedIfChanged {
+    if (!self.viewIfLoaded.window) {
+        return;
+    }
+    BOOL stacked = self.columnsStacked;
+    if (_sentColumnsStacked && _sentColumnsStacked.boolValue == stacked) {
+        return;
+    }
+    _sentColumnsStacked = @(stacked);
+    [self.eventEmitter sendSplitViewColumnsStacked:self.layoutInfo.componentId stacked:stacked];
+}
+
+- (BOOL)goBackFromColumnOf:(UIViewController *)screen completion:(dispatch_block_t)completion {
+    UINavigationController *stack = screen.stack;
+    // Only for the column on top of the collapsed stack (the columns under it, and those never shown, are out of the
+    // window), and only when its stack has nothing to pop: otherwise the pop goes as in any stack, or rejects.
+    if (!stack || !self.columnsStacked || !stack.viewIfLoaded.window ||
+        stack.viewControllers.count != 1) {
+        return NO;
+    }
+    // Its one entry is the screen, or the arrangement it is a screen of.
+    UIViewController *only = stack.viewControllers.firstObject;
+    BOOL isOnly = NO;
+    for (UIViewController *entry = screen; entry && entry != stack; entry = entry.layoutParent) {
+        if (entry == only) {
+            isOnly = YES;
+            break;
+        }
+    }
+    if (!isOnly) {
+        return NO;
+    }
+    UISplitViewControllerColumn previous;
+    if (stack == _columns[@"secondary"]) {
+        previous = _columns[@"supplementary"] ? UISplitViewControllerColumnSupplementary
+                                              : UISplitViewControllerColumnPrimary;
+    } else if (stack == _columns[@"supplementary"]) {
+        previous = UISplitViewControllerColumnPrimary;
+    } else {
+        return NO;
+    }
+    // A pop of the column's own stack at its root does nothing: showing the column before it takes the column's
+    // navigation controller off the primary's stack. The split view shows another column then.
+    __weak ANNSplitViewController *weakSelf = self;
+    [self performColumnChange:^{
+      [self showColumn:previous];
+    }
+                   completion:^{
+                     ANNSplitViewController *splitView = weakSelf;
+                     if (splitView) {
+                         [ANNShownScreens changedIn:splitView];
+                     }
+                     completion();
+                   }];
+    return YES;
+}
+
+- (void)showScreen:(UIViewController *)screen
+              inColumn:(NSString *)column
+    fromViewController:(UIViewController *)fromViewController
+            completion:(ANNTransitionCompletionBlock)completion
+             rejection:(ANNTransitionRejectionBlock)rejection {
+    UIViewController *previous = _columns[column];
+    if (!previous) {
+        rejection([NSString stringWithFormat:@"the split view of the screen '%@' has no '%@' column",
+                                             fromViewController.layoutInfo.componentId, column],
+                  nil);
+        return;
+    }
+    if ([previous isKindOfClass:UINavigationController.class]) {
+        // UIKit does not take a navigation controller among the screens of another.
+        if ([screen isKindOfClass:UINavigationController.class]) {
+            rejection([NSString stringWithFormat:@"the '%@' column of the split view of the screen '%@' is a "
+                                                 @"stack: it takes a screen, not a stack",
+                                                 column, fromViewController.layoutInfo.componentId],
+                      nil);
+            return;
+        }
+        // In place, as a column of UIKit apps changes; UIKit animates a column it brings on top.
+        [(UINavigationController *)previous setStackChildren:@[ screen ]
+                                          fromViewController:fromViewController
+                                                    animated:NO
+                                                  completion:^{
+                                                    [self performColumnChange:^{
+                                                      [self showColumn:ANNSplitViewColumn(column)];
+                                                    }
+                                                                   completion:completion];
+                                                  }
+                                                   rejection:rejection];
+        return;
+    }
+    // A screen alone: UIKit keeps it in a navigation controller of its own and puts the new screen in its place
+    // there, with the screens pushed over it gone. They go once the change is made and they have disappeared.
+    NSArray<UIViewController *> *gone = previous.navigationController.viewControllers ?: @[ previous ];
+    NSMutableDictionary<NSString *, UIViewController *> *columns = [_columns mutableCopy];
+    columns[column] = screen;
+    _columns = [columns copy];
+    [self
+        performColumnChange:^{
+          [self setViewController:screen forColumn:ANNSplitViewColumn(column)];
+          [self showColumn:ANNSplitViewColumn(column)];
+        }
+                 completion:^{
+                   for (UIViewController *each in gone) {
+                       if (each != screen) {
+                           [each destroy];
+                       }
+                   }
+                   completion();
+                 }];
+}
+
+// `done` once the change and the column it brings into view are on screen. A transition UIKit runs for them ends it;
+// otherwise the end of the transaction they are made in, which an animation in a column that never ends would hold:
+// a second at most then.
+- (void)performColumnChange:(dispatch_block_t)change completion:(dispatch_block_t)done {
+    __block BOOL finished = NO;
+    dispatch_block_t finish = ^{
+      if (!finished) {
+          finished = YES;
+          done();
+      }
+    };
+    [CATransaction begin];
+    change();
+    id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
+    if (coordinator) {
+        [coordinator animateAlongsideTransition:nil
+                                     completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                       finish();
+                                     }];
+    } else {
+        [CATransaction setCompletionBlock:finish];
+    }
+    [CATransaction commit];
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), finish);
+}
+
+// The compact layout while the split view is collapsed into it; collapsed without one, the column UIKit put on top of
+// the one stack it shows (the secondary's navigation controller in the primary's stack, else the supplementary's), else
+// the primary; side by side, also before the split view is in a window, the secondary.
+- (UIViewController *)getCurrentChild {
+    if (self.isCollapsedIntoCompact) {
+        return _columns[@"compact"];
+    }
+    UIViewController *primary = _columns[@"primary"];
+    if (!self.isCollapsed) {
+        return _columns[@"secondary"] ?: primary;
+    }
+    UINavigationController *primaryStack = [primary isKindOfClass:UINavigationController.class]
+                                               ? (UINavigationController *)primary
+                                               : primary.navigationController;
+    NSArray<UIViewController *> *stacked = primaryStack.viewControllers ?: @[];
+    for (NSString *name in @[ @"secondary", @"supplementary" ]) {
+        UIViewController *column = _columns[name];
+        if (!column) {
+            continue;
+        }
+        // A column that is a screen alone is in a navigation controller of UIKit's own.
+        BOOL isStack = [column isKindOfClass:UINavigationController.class];
+        UIViewController *columnStack = isStack ? column : column.navigationController;
+        if (columnStack && columnStack != primaryStack &&
+            [stacked indexOfObjectIdenticalTo:columnStack] != NSNotFound) {
+            return column;
+        }
+    }
+    return primary;
+}
+
+// The columns UIKit shows, the secondary first; collapsed, the screens of the current child.
+- (NSArray<UIViewController *> *)shownComponentViewControllers {
+    if (self.isCollapsed) {
+        return self.getCurrentChild.shownComponentViewControllers ?: @[];
+    }
+    NSMutableArray<UIViewController *> *screens = [NSMutableArray new];
+    for (NSString *name in @[ @"secondary", @"supplementary", @"primary", @"inspector" ]) {
+        UIViewController *column = _columns[name];
+        if (column.viewIfLoaded.window) {
+            [screens addObjectsFromArray:column.shownComponentViewControllers];
+        }
+    }
+    return screens.count ? screens : (self.getCurrentChild.shownComponentViewControllers ?: @[]);
+}
+
+// Every column of the layout, also one UIKit does not show now.
+- (NSArray<UIViewController *> *)layoutChildren {
+    NSMutableArray<UIViewController *> *children = [NSMutableArray new];
+    for (NSString *name in ANNSplitViewColumnNames()) {
+        if (_columns[name]) {
+            [children addObject:_columns[name]];
+        }
+    }
+    return children;
+}
+
+#pragma mark - UISplitViewControllerDelegate
+
+static NSString *ANNDisplayModeName(UISplitViewControllerDisplayMode displayMode) {
+    switch (displayMode) {
+    case UISplitViewControllerDisplayModeSecondaryOnly:
+        return @"secondaryOnly";
+    case UISplitViewControllerDisplayModeOneBesideSecondary:
+        return @"oneBesideSecondary";
+    case UISplitViewControllerDisplayModeOneOverSecondary:
+        return @"oneOverSecondary";
+    case UISplitViewControllerDisplayModeTwoBesideSecondary:
+        return @"twoBesideSecondary";
+    case UISplitViewControllerDisplayModeTwoOverSecondary:
+        return @"twoOverSecondary";
+    case UISplitViewControllerDisplayModeTwoDisplaceSecondary:
+        return @"twoDisplaceSecondary";
+    default:
+        return @"automatic";
+    }
+}
+
+// Once UIKit has made the change: the inspector shows or hides with it. The same state is sent
+// once.
+- (void)sendDisplayMode:(UISplitViewControllerDisplayMode)displayMode {
+    __weak ANNSplitViewController *weakSelf = self;
+    void (^send)(void) = ^{
+      ANNSplitViewController *strongSelf = weakSelf;
+      if (!strongSelf) {
+          return;
+      }
+      NSNumber *inspectorVisible = nil;
+      if (@available(iOS 26.0, *)) {
+          if (strongSelf->_columns[@"inspector"]) {
+              inspectorVisible =
+                  @([strongSelf isShowingColumn:UISplitViewControllerColumnInspector]);
+          }
+      }
+      NSString *name = ANNDisplayModeName(displayMode);
+      NSString *state = [NSString stringWithFormat:@"%@ %@", name, inspectorVisible];
+      if ([state isEqualToString:strongSelf->_sentDisplayModeState]) {
+          return;
+      }
+      strongSelf->_sentDisplayModeState = state;
+      [strongSelf.eventEmitter sendSplitViewDisplayModeChanged:strongSelf.layoutInfo.componentId
+                                                   displayMode:name
+                                              inspectorVisible:inspectorVisible];
+    };
+    id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
+    if (coordinator) {
+        [coordinator
+            animateAlongsideTransition:nil
+                            completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                              send();
+                            }];
+    } else {
+        dispatch_async(dispatch_get_main_queue(), send);
+    }
+}
+
+// Also when the split view first lays out its columns.
+- (void)splitViewController:(UISplitViewController *)svc
+    willChangeToDisplayMode:(UISplitViewControllerDisplayMode)displayMode {
+    [self sendDisplayMode:displayMode];
+    // A column that shows or hides: a layer that waits to show takes its screens again.
+    [ANNShownScreens changedIn:self];
+}
+
+- (void)splitViewController:(UISplitViewController *)svc
+              didShowColumn:(UISplitViewControllerColumn)column API_AVAILABLE(ios(26.0)) {
+    if (column == UISplitViewControllerColumnInspector) {
+        [self sendDisplayMode:self.displayMode];
+    }
+}
+
+- (void)splitViewController:(UISplitViewController *)svc
+              didHideColumn:(UISplitViewControllerColumn)column API_AVAILABLE(ios(26.0)) {
+    if (column == UISplitViewControllerColumnInspector) {
+        [self sendDisplayMode:self.displayMode];
+    }
+}
+
+// `splitView.compactTopColumn`: the column on top when the columns collapse into one stack (without
+// a compact layout); UIKit's choice without the option.
+- (UISplitViewControllerColumn)splitViewController:(UISplitViewController *)svc
+         topColumnForCollapsingToProposedTopColumn:(UISplitViewControllerColumn)proposedTopColumn {
+    NSString *top = self.resolveOptionsWithDefault.splitView.compactTopColumn;
+    if ([top isEqualToString:@"primary"]) {
+        return UISplitViewControllerColumnPrimary;
+    }
+    if ([top isEqualToString:@"secondary"]) {
+        return UISplitViewControllerColumnSecondary;
+    }
+    return proposedTopColumn;
+}
+
+- (void)splitViewControllerDidCollapse:(UISplitViewController *)svc {
+    [self sendColumnsStackedIfChanged];
+    [self shownColumnsChanged];
+}
+
+- (void)splitViewControllerDidExpand:(UISplitViewController *)svc {
+    [self sendColumnsStackedIfChanged];
+    [self shownColumnsChanged];
+}
+
+#pragma mark - UIViewController
+
+- (UIStatusBarStyle)preferredStatusBarStyle {
+    return [self.presenter statusBarStyleForOptions:self.resolveOptionsWithDefault];
+}
+
+- (BOOL)prefersStatusBarHidden {
+    return [self.presenter statusBarHiddenForOptions:self.resolveOptionsWithDefault];
+}
+
+- (UIInterfaceOrientationMask)supportedInterfaceOrientations {
+    return [self.presenter supportedOrientationsForOptions:self.resolveOptionsWithDefault];
+}
+
+// The system UI follows the main column, or the compact layout while collapsed into it.
+- (UIViewController *)systemUIChild {
+    if (self.isCollapsedIntoCompact) {
+        return _columns[@"compact"];
+    }
+    return _columns[@"secondary"];
+}
+
+- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden {
+    return self.systemUIChild;
+}
+
+- (UIViewController *)childViewControllerForScreenEdgesDeferringSystemGestures {
+    return self.systemUIChild;
+}
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+// `layout.verticalBars` of the main column's screen, as the home indicator.
+- (UIViewController *)childViewControllerForPreferredVerticalBarBehavior API_AVAILABLE(ios(27.1)) {
+    return self.systemUIChild;
+}
+#endif
+
+- (BOOL)hidesBottomBarWhenPushed {
+    return [self.presenter hidesBottomBarWhenPushedForOptions:self.resolveOptionsWithDefault];
+}
+
+@end

package/ios/Layouts/SplitView/ANNSplitViewPresenter.h

@@ -0,0 +1,18 @@
+#import "ANNNodePresenter.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The presenter of a split view (`splitView.*`): it turns `splitView.*` into the calls of the split view module's
+/// category (`UISplitViewController+ANNOptions`).
+///
+/// When: at creation every field, `displayMode` and `inspector.visible` too, without animation; at every appearance
+/// of a screen inside (`descendantWillAppear:`) and at the repaint of new default options, every field but
+/// `displayMode` and `inspector.visible` (the user's choice lives until a merge); at a merge into the split view, or
+/// one that came up from a screen inside, only the fields the merge names, `inspector.visible` animated. The values
+/// come from the split view's resolved options with the defaults. A screen's merge that names `splitView` goes into the
+/// split view's own options too, and the split view's parents get merges without `splitView`. No `testID` on iOS: UIKit
+/// gives a column-style split view no button to put it on.
+@interface ANNSplitViewPresenter : ANNNodePresenter
+@end
+
+NS_ASSUME_NONNULL_END