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

package/ios/Core/ANNEventEmitter.h

@@ -0,0 +1,174 @@
+#import "ANNComponentType.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class ANNTurboEventEmitter;
+
+/// The core's sender of the events `ANN.<Name>` to JavaScript. It goes through the emitter module of the current
+/// JavaScript (`ANNTurboEventEmitter`) on the main queue, so events and answers reach JavaScript in the order the
+/// native side sent them. While JavaScript listens to no event (none runs yet, or a reload is under way) an event is
+/// dropped silently.
+///
+/// An emitter belongs to one JavaScript: it takes the generation of `ANNReloadCoordinator` when it is made and drops
+/// every event once that generation moved. `ApexNavigation.eventEmitter` gives the emitter of the JavaScript that runs
+/// now; every node and content keeps the one it was made with, so the screens of a JavaScript that went tell the new
+/// one nothing.
+@interface ANNEventEmitter : NSObject
+
+/// The generation of the JavaScript this emitter sends to.
+@property(nonatomic, readonly) NSUInteger generation;
+
+/// Whether the JavaScript of this emitter still runs: its events go only then. Any thread.
+@property(nonatomic, readonly) BOOL isCurrent;
+
+/// Sends `ANN.<name>` with the payload as it is. From another queue it moves to the main queue first.
+- (void)sendEvent:(NSString *)name body:(nullable NSDictionary<NSString *, id> *)body;
+
+#pragma mark - The contract
+
+/// `ANN.AppLaunched`, without a payload. While JavaScript has no listener of it, it is kept and goes once JavaScript
+/// adds the first one. Main queue.
+- (void)sendAppLaunched;
+
+/// `ANN.CommandCompleted { commandName, commandId, completionTime }`, the time in milliseconds since 1970
+/// (EVT-CommandCompleted).
+- (void)sendCommandCompleted:(NSString *)commandName
+                   commandId:(NSString *)commandId
+              completionTime:(double)completionTime;
+
+/// The emitter module tells that JavaScript added its first listener of `ANN.AppLaunched`: a kept `AppLaunched` goes
+/// now. Main queue.
++ (void)eventEmitterListensToAppLaunched:(ANNTurboEventEmitter *)eventEmitter;
+
+/// The emitter module of a JavaScript that went is invalidated: an `AppLaunched` kept for that JavaScript, which never
+/// listened to it, is dropped, so that the next JavaScript gets only its own. Main queue.
++ (void)eventEmitterWentAway:(ANNTurboEventEmitter *)eventEmitter;
+
+#pragma mark - Screens
+
+- (void)sendComponentWillAppear:(NSString *)componentId
+                  componentName:(NSString *)componentName
+                  componentType:(ANNReactComponentType)componentType;
+
+- (void)sendComponentDidAppear:(NSString *)componentId
+                 componentName:(NSString *)componentName
+                 componentType:(ANNReactComponentType)componentType;
+
+- (void)sendComponentDidDisappear:(NSString *)componentId
+                    componentName:(NSString *)componentName
+                    componentType:(ANNReactComponentType)componentType;
+
+/// `ANN.NavigationButtonPressed { componentId, buttonId }`.
+- (void)sendOnNavigationButtonPressed:(NSString *)componentId buttonId:(NSString *)buttonId;
+
+/// `ANN.NavigationButtonPressed { componentId, buttonId, selected? }`: `selected` only for a button with `toggle`, its
+/// new state, left out when nil.
+- (void)sendOnNavigationButtonPressed:(NSString *)componentId
+                             buttonId:(NSString *)buttonId
+                             selected:(nullable NSNumber *)selected;
+
+/// `ANN.ScreenPopped { componentId }`: the screen left its stack (EVT-ScreenPopped).
+- (void)sendScreenPopped:(NSString *)componentId;
+
+/// `ANN.NavigationStateChanged { screen: { id, name } | null, tab: number | null }`: a nil screen id sends `null` for
+/// the screen, a nil tab `null` for the tab (EVT-NavigationStateChanged).
+- (void)sendNavigationStateChanged:(nullable NSString *)screenId
+                              name:(nullable NSString *)name
+                               tab:(nullable NSNumber *)tab;
+
+- (void)sendScreenInsetsChanged:(NSString *)componentId
+                         insets:(NSDictionary<NSString *, NSNumber *> *)insets;
+
+- (void)sendScreenRegionsChanged:(NSString *)componentId
+                         regions:(NSDictionary<NSString *, NSArray *> *)regions;
+
+- (void)sendSlotDestroyed:(NSString *)componentId;
+
+/// `ANN.TitleRenamed { componentId, text }` (EVT-TitleRenamed).
+- (void)sendTitleRenamed:(NSString *)componentId text:(NSString *)text;
+
+/// `ANN.KeyCommandPressed { componentId, keyCommandId }` (EVT-KeyCommandPressed).
+- (void)sendKeyCommandPressed:(NSString *)componentId keyCommandId:(NSString *)keyCommandId;
+
+/// `ANN.PreviewCompleted { componentId, previewComponentId }` (EVT-PreviewCompleted).
+- (void)sendPreviewCompleted:(NSString *)componentId
+          previewComponentId:(NSString *)previewComponentId;
+
+#pragma mark - Modals
+
+/// `ANN.ModalDismissed { componentId, componentName, modalsDismissed }`: the id and the name of the modal's visible
+/// screen (EVT-ModalDismissed).
+- (void)sendModalDismissed:(NSString *)componentId
+             componentName:(NSString *)componentName
+           modalsDismissed:(NSUInteger)modalsDismissed;
+
+/// `ANN.ModalAttemptedToDismiss { componentId }` (EVT-ModalAttemptedToDismiss).
+- (void)sendModalAttemptedToDismiss:(NSString *)componentId;
+
+/// `ANN.SheetDetentChanged { componentId, detent }`: `detent` is `'medium'`, `'large'`, `'content'` or a number
+/// (EVT-SheetDetentChanged).
+- (void)sendSheetDetentChanged:(NSString *)componentId detent:(id)detent;
+
+#pragma mark - Search
+
+- (void)sendOnSearchBarUpdated:(NSString *)componentId
+                          text:(NSString *)text
+                     isFocused:(BOOL)isFocused
+                         scope:(nullable NSString *)scope
+                        tokens:(nullable NSArray<NSString *> *)tokens;
+
+- (void)sendOnSearchBarSubmitted:(NSString *)componentId
+                            text:(NSString *)text
+                           scope:(nullable NSString *)scope
+                          tokens:(nullable NSArray<NSString *> *)tokens;
+
+- (void)sendOnSearchBarCancelPressed:(NSString *)componentId;
+
+- (void)sendOnSearchSuggestionPicked:(NSString *)componentId suggestionId:(NSString *)suggestionId;
+
+#pragma mark - Split view, pair, hinge
+
+- (void)sendSplitViewColumnsStacked:(NSString *)componentId stacked:(BOOL)stacked;
+
+/// `inspectorVisible` only for a split view with an inspector column.
+- (void)sendSplitViewDisplayModeChanged:(NSString *)componentId
+                            displayMode:(NSString *)displayMode
+                       inspectorVisible:(nullable NSNumber *)inspectorVisible;
+
+/// `state` is `{ placement, layout, front, hidden }`.
+- (void)sendArrangementChanged:(NSString *)componentId state:(NSDictionary<NSString *, id> *)state;
+
+/// `value` is `{ state, angle }`, or `{}` without a hinge.
+- (void)sendHingeChanged:(NSDictionary<NSString *, id> *)value;
+
+#pragma mark - Native screens, tabs
+
+/// `call` is `{ componentId, callId, kind, name, args }`.
+- (void)sendNativeScreenCall:(NSDictionary<NSString *, id> *)call;
+
+/// `ANN.NativeScreenReleased { componentId }` (EVT-NativeScreenReleased).
+- (void)sendNativeScreenReleased:(NSString *)componentId;
+
+/// `ANN.BottomTabSelected { selectedTabIndex, unselectedTabIndex, bottomTabsId }` (EVT-BottomTabSelected).
+- (void)sendBottomTabSelected:(NSUInteger)selectedTabIndex
+           unselectedTabIndex:(NSUInteger)unselectedTabIndex
+                 bottomTabsId:(NSString *)bottomTabsId;
+
+/// `ANN.BottomTabPressed { tabIndex, bottomTabsId, screenId?, wasSelected }`: `screenId` left out when nil
+/// (EVT-BottomTabPressed).
+- (void)sendBottomTabPressed:(NSUInteger)tabIndex
+                bottomTabsId:(NSString *)bottomTabsId
+                    screenId:(nullable NSString *)screenId
+                 wasSelected:(BOOL)wasSelected;
+
+/// `ANN.BottomTabLongPressed { selectedTabIndex, bottomTabsId }`: the index of the tab pressed
+/// (EVT-BottomTabLongPressed).
+- (void)sendBottomTabLongPressed:(NSUInteger)selectedTabIndex
+                    bottomTabsId:(NSString *)bottomTabsId;
+
+- (void)sendBottomAccessoryPlacementChanged:(NSString *)componentId placement:(NSString *)placement;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNEventEmitter.mm

@@ -0,0 +1,337 @@
+#import "ANNEventEmitter.h"
+#import "ANNAssert.h"
+#import "ANNReloadCoordinator.h"
+#import "ANNTurboEventEmitter.h"
+#import <React/RCTUtils.h>
+
+static NSString *ANNComponentTypeName(ANNReactComponentType componentType) {
+    switch (componentType) {
+    case ANNComponentTypeTopBarTitle:
+        return @"TopBarTitle";
+    case ANNComponentTypeTopBarButton:
+        return @"TopBarButton";
+    case ANNComponentTypeTopBarBackground:
+        return @"TopBarBackground";
+    case ANNComponentTypeBottomTabItem:
+        return @"BottomTabItem";
+    default:
+        return @"Component";
+    }
+}
+
+// Whether an `AppLaunched` waits for JavaScript to listen to it, and the bundle it is for (the count of bundles when it
+// was kept). Main queue.
+static BOOL ANNAppLaunchedPending;
+static NSUInteger ANNAppLaunchedBundle;
+
+static NSString *const ANNAppLaunchedEvent = @"ANN.AppLaunched";
+
+@implementation ANNEventEmitter
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _generation = ANNReloadCoordinator.generation;
+    }
+    return self;
+}
+
+- (BOOL)isCurrent {
+    return _generation == ANNReloadCoordinator.generation;
+}
+
+// The generation is checked where the event goes out, on the main queue: an event sent from another queue just
+// before a reload is dropped too.
+- (void)sendEvent:(NSString *)name body:(NSDictionary<NSString *, id> *)body {
+    NSString *eventName = [@"ANN." stringByAppendingString:name];
+    RCTExecuteOnMainQueue(^{
+      if (!self.isCurrent) {
+          return;
+      }
+      [ANNTurboEventEmitter.current sendIfListened:eventName body:body];
+    });
+}
+
+#pragma mark - The contract
+
+- (void)sendAppLaunched {
+    ANNAssertMainQueue();
+    ANNTurboEventEmitter *eventEmitter = ANNTurboEventEmitter.current;
+    if (!eventEmitter.listensToAppLaunched) {
+        ANNAppLaunchedPending = YES;
+        ANNAppLaunchedBundle = ANNReloadCoordinator.bundleCount;
+        return;
+    }
+    ANNAppLaunchedPending = NO;
+    [eventEmitter sendIfListened:ANNAppLaunchedEvent body:nil];
+}
+
++ (void)eventEmitterListensToAppLaunched:(ANNTurboEventEmitter *)eventEmitter {
+    ANNAssertMainQueue();
+    if (!ANNAppLaunchedPending) {
+        return;
+    }
+    ANNAppLaunchedPending = NO;
+    [eventEmitter sendIfListened:ANNAppLaunchedEvent body:nil];
+}
+
+// Only an `AppLaunched` of the module's own JavaScript or an older one: the module is made while its bundle runs,
+// before that bundle counts, so its JavaScript's is the next bundle at most. One kept for a newer bundle stays, also
+// when the old module goes late.
++ (void)eventEmitterWentAway:(ANNTurboEventEmitter *)eventEmitter {
+    ANNAssertMainQueue();
+    if (ANNAppLaunchedPending && ANNAppLaunchedBundle <= eventEmitter.bundlesBefore + 1) {
+        ANNAppLaunchedPending = NO;
+    }
+}
+
+- (void)sendCommandCompleted:(NSString *)commandName
+                   commandId:(NSString *)commandId
+              completionTime:(double)completionTime {
+    [self sendEvent:@"CommandCompleted"
+               body:@{
+                   @"commandName" : commandName,
+                   @"commandId" : commandId,
+                   @"completionTime" : @(completionTime),
+               }];
+}
+
+#pragma mark - Screens
+
+- (void)sendComponentWillAppear:(NSString *)componentId
+                  componentName:(NSString *)componentName
+                  componentType:(ANNReactComponentType)componentType {
+    [self sendComponentEvent:@"ComponentWillAppear"
+                 componentId:componentId
+               componentName:componentName
+               componentType:componentType];
+}
+
+- (void)sendComponentDidAppear:(NSString *)componentId
+                 componentName:(NSString *)componentName
+                 componentType:(ANNReactComponentType)componentType {
+    [self sendComponentEvent:@"ComponentDidAppear"
+                 componentId:componentId
+               componentName:componentName
+               componentType:componentType];
+}
+
+- (void)sendComponentDidDisappear:(NSString *)componentId
+                    componentName:(NSString *)componentName
+                    componentType:(ANNReactComponentType)componentType {
+    [self sendComponentEvent:@"ComponentDidDisappear"
+                 componentId:componentId
+               componentName:componentName
+               componentType:componentType];
+}
+
+- (void)sendComponentEvent:(NSString *)name
+               componentId:(NSString *)componentId
+             componentName:(NSString *)componentName
+             componentType:(ANNReactComponentType)componentType {
+    [self sendEvent:name
+               body:@{
+                   @"componentId" : componentId ?: @"",
+                   @"componentName" : componentName ?: @"",
+                   @"componentType" : ANNComponentTypeName(componentType),
+               }];
+}
+
+- (void)sendOnNavigationButtonPressed:(NSString *)componentId buttonId:(NSString *)buttonId {
+    [self sendOnNavigationButtonPressed:componentId buttonId:buttonId selected:nil];
+}
+
+- (void)sendOnNavigationButtonPressed:(NSString *)componentId
+                             buttonId:(NSString *)buttonId
+                             selected:(NSNumber *)selected {
+    NSMutableDictionary *body =
+        [@{@"componentId" : componentId ?: @"", @"buttonId" : buttonId ?: @""} mutableCopy];
+    if (selected) {
+        body[@"selected"] = @(selected.boolValue);
+    }
+    [self sendEvent:@"NavigationButtonPressed" body:body];
+}
+
+- (void)sendScreenPopped:(NSString *)componentId {
+    [self sendEvent:@"ScreenPopped" body:@{@"componentId" : componentId ?: @""}];
+}
+
+- (void)sendNavigationStateChanged:(NSString *)screenId name:(NSString *)name tab:(NSNumber *)tab {
+    id screen = screenId ? @{@"id" : screenId, @"name" : name ?: @""} : (id)NSNull.null;
+    [self sendEvent:@"NavigationStateChanged"
+               body:@{@"screen" : screen, @"tab" : tab ?: (id)NSNull.null}];
+}
+
+- (void)sendScreenInsetsChanged:(NSString *)componentId
+                         insets:(NSDictionary<NSString *, NSNumber *> *)insets {
+    NSMutableDictionary *body = [insets mutableCopy] ?: [NSMutableDictionary new];
+    body[@"componentId"] = componentId;
+    [self sendEvent:@"ScreenInsetsChanged" body:body];
+}
+
+- (void)sendScreenRegionsChanged:(NSString *)componentId
+                         regions:(NSDictionary<NSString *, NSArray *> *)regions {
+    NSMutableDictionary *body = [regions mutableCopy] ?: [NSMutableDictionary new];
+    body[@"componentId"] = componentId;
+    [self sendEvent:@"ScreenRegionsChanged" body:body];
+}
+
+- (void)sendSlotDestroyed:(NSString *)componentId {
+    [self sendEvent:@"SlotDestroyed" body:@{@"componentId" : componentId ?: @""}];
+}
+
+- (void)sendTitleRenamed:(NSString *)componentId text:(NSString *)text {
+    [self sendEvent:@"TitleRenamed"
+               body:@{@"componentId" : componentId ?: @"", @"text" : text ?: @""}];
+}
+
+- (void)sendKeyCommandPressed:(NSString *)componentId keyCommandId:(NSString *)keyCommandId {
+    [self sendEvent:@"KeyCommandPressed"
+               body:@{@"componentId" : componentId ?: @"", @"keyCommandId" : keyCommandId ?: @""}];
+}
+
+- (void)sendPreviewCompleted:(NSString *)componentId
+          previewComponentId:(NSString *)previewComponentId {
+    [self sendEvent:@"PreviewCompleted"
+               body:@{
+                   @"componentId" : componentId ?: @"",
+                   @"previewComponentId" : previewComponentId ?: @"",
+               }];
+}
+
+#pragma mark - Modals
+
+- (void)sendModalDismissed:(NSString *)componentId
+             componentName:(NSString *)componentName
+           modalsDismissed:(NSUInteger)modalsDismissed {
+    [self sendEvent:@"ModalDismissed"
+               body:@{
+                   @"componentId" : componentId ?: @"",
+                   @"componentName" : componentName ?: @"",
+                   @"modalsDismissed" : @(modalsDismissed),
+               }];
+}
+
+- (void)sendModalAttemptedToDismiss:(NSString *)componentId {
+    [self sendEvent:@"ModalAttemptedToDismiss" body:@{@"componentId" : componentId ?: @""}];
+}
+
+- (void)sendSheetDetentChanged:(NSString *)componentId detent:(id)detent {
+    [self sendEvent:@"SheetDetentChanged"
+               body:@{@"componentId" : componentId ?: @"", @"detent" : detent ?: @""}];
+}
+
+#pragma mark - Search
+
+- (void)sendOnSearchBarUpdated:(NSString *)componentId
+                          text:(NSString *)text
+                     isFocused:(BOOL)isFocused
+                         scope:(NSString *)scope
+                        tokens:(NSArray<NSString *> *)tokens {
+    NSMutableDictionary *body = [@{
+        @"componentId" : componentId ?: @"",
+        @"text" : text ?: @"",
+        @"isFocused" : @(isFocused),
+    } mutableCopy];
+    body[@"scope"] = scope;
+    body[@"tokens"] = tokens;
+    [self sendEvent:@"SearchBarUpdated" body:body];
+}
+
+- (void)sendOnSearchBarSubmitted:(NSString *)componentId
+                            text:(NSString *)text
+                           scope:(NSString *)scope
+                          tokens:(NSArray<NSString *> *)tokens {
+    NSMutableDictionary *body =
+        [@{@"componentId" : componentId ?: @"", @"text" : text ?: @""} mutableCopy];
+    body[@"scope"] = scope;
+    body[@"tokens"] = tokens;
+    [self sendEvent:@"SearchBarSubmitted" body:body];
+}
+
+- (void)sendOnSearchBarCancelPressed:(NSString *)componentId {
+    [self sendEvent:@"SearchBarCancelPressed" body:@{@"componentId" : componentId ?: @""}];
+}
+
+- (void)sendOnSearchSuggestionPicked:(NSString *)componentId suggestionId:(NSString *)suggestionId {
+    [self sendEvent:@"SearchSuggestionPicked"
+               body:@{@"componentId" : componentId ?: @"", @"suggestionId" : suggestionId ?: @""}];
+}
+
+#pragma mark - Split view, pair, hinge
+
+- (void)sendSplitViewColumnsStacked:(NSString *)componentId stacked:(BOOL)stacked {
+    [self sendEvent:@"SplitViewColumnsStacked"
+               body:@{@"componentId" : componentId ?: @"", @"stacked" : @(stacked)}];
+}
+
+- (void)sendSplitViewDisplayModeChanged:(NSString *)componentId
+                            displayMode:(NSString *)displayMode
+                       inspectorVisible:(NSNumber *)inspectorVisible {
+    NSMutableDictionary *body = [@{
+        @"componentId" : componentId ?: @"",
+        @"displayMode" : displayMode ?: @"automatic",
+    } mutableCopy];
+    body[@"inspectorVisible"] = inspectorVisible;
+    [self sendEvent:@"SplitViewDisplayModeChanged" body:body];
+}
+
+- (void)sendArrangementChanged:(NSString *)componentId state:(NSDictionary<NSString *, id> *)state {
+    NSMutableDictionary *body = [state mutableCopy] ?: [NSMutableDictionary new];
+    body[@"componentId"] = componentId;
+    [self sendEvent:@"ArrangementChanged" body:body];
+}
+
+- (void)sendHingeChanged:(NSDictionary<NSString *, id> *)value {
+    [self sendEvent:@"HingeChanged" body:value ?: @{}];
+}
+
+#pragma mark - Native screens, tabs
+
+- (void)sendNativeScreenCall:(NSDictionary<NSString *, id> *)call {
+    [self sendEvent:@"NativeScreenCall" body:call];
+}
+
+- (void)sendNativeScreenReleased:(NSString *)componentId {
+    [self sendEvent:@"NativeScreenReleased" body:@{@"componentId" : componentId ?: @""}];
+}
+
+- (void)sendBottomTabSelected:(NSUInteger)selectedTabIndex
+           unselectedTabIndex:(NSUInteger)unselectedTabIndex
+                 bottomTabsId:(NSString *)bottomTabsId {
+    [self sendEvent:@"BottomTabSelected"
+               body:@{
+                   @"selectedTabIndex" : @(selectedTabIndex),
+                   @"unselectedTabIndex" : @(unselectedTabIndex),
+                   @"bottomTabsId" : bottomTabsId ?: @"",
+               }];
+}
+
+- (void)sendBottomTabPressed:(NSUInteger)tabIndex
+                bottomTabsId:(NSString *)bottomTabsId
+                    screenId:(NSString *)screenId
+                 wasSelected:(BOOL)wasSelected {
+    NSMutableDictionary *body = [@{
+        @"tabIndex" : @(tabIndex),
+        @"bottomTabsId" : bottomTabsId ?: @"",
+        @"wasSelected" : @(wasSelected),
+    } mutableCopy];
+    body[@"screenId"] = screenId;
+    [self sendEvent:@"BottomTabPressed" body:body];
+}
+
+- (void)sendBottomTabLongPressed:(NSUInteger)selectedTabIndex
+                    bottomTabsId:(NSString *)bottomTabsId {
+    [self sendEvent:@"BottomTabLongPressed"
+               body:@{
+                   @"selectedTabIndex" : @(selectedTabIndex),
+                   @"bottomTabsId" : bottomTabsId ?: @"",
+               }];
+}
+
+- (void)sendBottomAccessoryPlacementChanged:(NSString *)componentId
+                                  placement:(NSString *)placement {
+    [self sendEvent:@"BottomAccessoryPlacementChanged"
+               body:@{@"componentId" : componentId ?: @"", @"placement" : placement ?: @""}];
+}
+
+@end

package/ios/Core/ANNHinge.h

@@ -0,0 +1,26 @@
+#import "ANNEventEmitter.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Posted on the main queue when the state of the hinge changes (closed, partly open, open), once a screen showed.
+extern NSNotificationName const ANNHingeDidChangeNotification;
+
+/// The device's hinge (`useHinge`), iOS 27.1: one UIHingeInteraction on the app's window, which runs once a screen
+/// showed (the regions of the screens follow the hinge's state) and while JavaScript asks for updates (it counts its
+/// hooks). While JavaScript asks, each new value goes as `ANN.HingeChanged`: `{ state, angle }`, the angle in degrees,
+/// or `{}` without a hinge.
+@interface ANNHinge : NSObject
+
+/// Starts or stops the updates to JavaScript. Main queue.
++ (void)setUpdatesEnabled:(BOOL)enabled eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
+
+/// Watches the hinge from now on, for the regions of the screens. Main queue.
++ (void)watchForScreens;
+
+/// The last value, `{}` before the first update and without a hinge. Any thread.
++ (NSDictionary<NSString *, id> *)lastValue;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Core/ANNHinge.mm

@@ -0,0 +1,116 @@
+#import "ANNHinge.h"
+#import "ANNAssert.h"
+#import "ANNUtils.h"
+
+NSNotificationName const ANNHingeDidChangeNotification = @"ANNHingeDidChange";
+
+// Main queue.
+static ANNEventEmitter *ANNHingeEventEmitter;
+static BOOL ANNHingeUpdatesEnabled;
+static BOOL ANNHingeWatchedForScreens;
+// Any thread, under @synchronized of the class.
+static NSDictionary<NSString *, id> *ANNLastHinge;
+
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+// Made once, with the first updates; main queue.
+static UIHingeInteraction *ANNHingeInteraction API_AVAILABLE(ios(27.1));
+
+static NSString *ANNHingeStateName(UIHingeStatus status) API_AVAILABLE(ios(27.1)) {
+    switch (status) {
+    case UIHingeStatusClosed:
+        return @"closed";
+    case UIHingeStatusPartiallyOpen:
+        return @"partiallyOpen";
+    case UIHingeStatusFullyOpen:
+        return @"fullyOpen";
+    default:
+        return @"unknown";
+    }
+}
+
+// The angle in degrees to a tenth: UIKit repeats the same angle once the hinge stops, and a tenth is finer than any
+// effect needs. While the state is unknown the angle says nothing and is left out.
+static NSDictionary<NSString *, id> *ANNHingeValue(UIHinge *hinge) API_AVAILABLE(ios(27.1)) {
+    if (!hinge) {
+        return @{};
+    }
+    NSString *state = ANNHingeStateName(hinge.status);
+    if (hinge.status == UIHingeStatusUnknown) {
+        return @{@"state" : state};
+    }
+    return @{@"state" : state, @"angle" : @(round(hinge.angle * 1800 / M_PI) / 10)};
+}
+#endif
+
+@implementation ANNHinge
+
++ (void)setUpdatesEnabled:(BOOL)enabled eventEmitter:(ANNEventEmitter *)eventEmitter {
+    ANNAssertMainQueue();
+    ANNHingeEventEmitter = eventEmitter;
+    ANNHingeUpdatesEnabled = enabled;
+    [self updateInteraction];
+}
+
++ (void)watchForScreens {
+    ANNAssertMainQueue();
+    ANNHingeWatchedForScreens = YES;
+    [self updateInteraction];
+}
+
+// The interaction runs while JavaScript asks for updates, and once a screen showed: a partial fold changes the regions
+// of a screen (`useReservedRegions`) with no change of its size or traits, and the hinge's state is how the screens
+// learn of it.
++ (void)updateInteraction {
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
+    if (@available(iOS 27.1, *)) {
+        BOOL enabled = ANNHingeUpdatesEnabled || ANNHingeWatchedForScreens;
+        if (!ANNHingeInteraction) {
+            if (!enabled) {
+                return;
+            }
+            void (^handler)(UIHingeInteraction *, UIHingeInteractionUpdate *) =
+                ^(UIHingeInteraction *interaction, UIHingeInteractionUpdate *update) {
+                  [ANNHinge hingeDidUpdate:ANNHingeValue(update.hinge)];
+                };
+            ANNHingeInteraction = [[UIHingeInteraction alloc] initWithUpdateHandler:handler];
+        }
+        // On the window the navigation shows in. A disabled interaction gets nothing, and the current value once it
+        // is enabled again.
+        UIWindow *window = ANNUtils.mainWindow;
+        if (enabled && window && ANNHingeInteraction.view != window) {
+            [ANNHingeInteraction.view removeInteraction:ANNHingeInteraction];
+            [window addInteraction:ANNHingeInteraction];
+        }
+        ANNHingeInteraction.enabled = enabled;
+    }
+#endif
+}
+
+// Each value once: UIKit repeats the last angle while the hinge stands still. `{}` once the interaction leaves the
+// window or the device has no hinge.
++ (void)hingeDidUpdate:(NSDictionary<NSString *, id> *)value {
+    id previousState = nil;
+    @synchronized(ANNHinge.class) {
+        if ([ANNLastHinge isEqualToDictionary:value]) {
+            return;
+        }
+        previousState = ANNLastHinge[@"state"];
+        ANNLastHinge = value;
+    }
+    if (ANNHingeUpdatesEnabled) {
+        [ANNHingeEventEmitter sendHingeChanged:value];
+    }
+    id state = value[@"state"];
+    if (previousState != state && ![previousState isEqual:state]) {
+        [NSNotificationCenter.defaultCenter postNotificationName:ANNHingeDidChangeNotification
+                                                          object:nil];
+    }
+}
+
++ (NSDictionary<NSString *, id> *)lastValue {
+    @synchronized(ANNHinge.class) {
+        return ANNLastHinge ?: @{};
+    }
+}
+
+@end

package/ios/Core/ANNKeyCommands.h

@@ -0,0 +1,12 @@
+#import <UIKit/UIKit.h>
+
+/**
+ * `keyCommands` of a screen: `{ id, input, modifiers, title }` as UIKeyCommands. `input` is a
+ * character or 'escape', 'enter', 'tab', 'delete', 'up', 'down', 'left', 'right'; `modifiers` are
+ * 'command', 'shift', 'option' (or 'alternate') and 'control'. The id of a command is its
+ * property list.
+ */
+NSArray<UIKeyCommand *> *ANNKeyCommandsFromOptions(NSArray<NSDictionary *> *options, SEL action);
+
+/** Nothing takes the keyboard now: no first responder, or the window or the app. */
+BOOL ANNNoFirstResponder(void);