@granite-js/micro-frontend 2.0.0

package/ios/PortalHostContainerView.mm

@@ -0,0 +1,133 @@
+#import "PortalHostContainerView.h"
+
+#import <React/RCTSurfaceTouchHandler.h>
+#import "PortalHostView.h"
+
+@implementation PortalHostContainerView {
+  PortalHostView *_portalHostView;
+  RCTSurfaceTouchHandler *_touchHandler;
+  NSString *_pendingName;
+  BOOL _hasAttachedContent;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  return [self initWithFrame:frame deferredActivation:NO];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame deferredActivation:(BOOL)deferredActivation
+{
+  if (self = [super initWithFrame:frame]) {
+    if (!deferredActivation) {
+      [self activateIfNeeded];
+    }
+  }
+  return self;
+}
+
+- (nullable instancetype)initWithCoder:(NSCoder *)coder
+{
+  if (self = [super initWithCoder:coder]) {
+    [self activateIfNeeded];
+  }
+  return self;
+}
+
+- (BOOL)isActivated
+{
+  return _portalHostView != nil;
+}
+
+- (BOOL)hasAttachedContent
+{
+  return _hasAttachedContent;
+}
+
+- (void)activateIfNeeded
+{
+  if (_portalHostView != nil) {
+    return;
+  }
+
+  _portalHostView = [[PortalHostView alloc] initWithFrame:self.bounds];
+  _portalHostView.autoresizingMask =
+      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  __weak PortalHostContainerView *weakSelf = self;
+  _portalHostView.onSubviewCountChanged = ^{
+    [weakSelf handleSubviewCountChanged];
+  };
+  [self addSubview:_portalHostView];
+
+  _touchHandler = [RCTSurfaceTouchHandler new];
+  [_touchHandler attachToView:self];
+
+  if (_pendingName) {
+    [_portalHostView setName:_pendingName];
+    _pendingName = nil;
+  }
+}
+
+- (void)setName:(nullable NSString *)name
+{
+  if (_portalHostView) {
+    [_portalHostView setName:name];
+  } else {
+    _pendingName = [name copy];
+  }
+}
+
+- (void)handleSubviewCountChanged
+{
+  NSUInteger count = _portalHostView.subviews.count;
+  if (count > 0) {
+    if (!_hasAttachedContent) {
+      _hasAttachedContent = YES;
+      if (self.onContentDidAttach) {
+        self.onContentDidAttach();
+      }
+    }
+    return;
+  }
+
+  if (!_hasAttachedContent) {
+    return;
+  }
+
+  // Removal and re-insertion can happen within a single mount commit (e.g.
+  // the content moves between hosts). Confirm emptiness on the next run loop
+  // before reporting a detach.
+  __weak PortalHostContainerView *weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    PortalHostContainerView *strongSelf = weakSelf;
+    if (!strongSelf || !strongSelf->_hasAttachedContent) {
+      return;
+    }
+    if (strongSelf->_portalHostView.subviews.count == 0) {
+      strongSelf->_hasAttachedContent = NO;
+      if (strongSelf.onContentDidDetach) {
+        strongSelf.onContentDidDetach();
+      }
+    }
+  });
+}
+
+- (void)invalidate
+{
+  _pendingName = nil;
+  _portalHostView.onSubviewCountChanged = nil;
+  [_portalHostView setName:nil];
+  self.onContentDidAttach = nil;
+  self.onContentDidDetach = nil;
+}
+
+- (void)dealloc
+{
+  [_portalHostView setName:nil];
+  // Do not call -detachFromView: here. RCTSurfaceTouchHandler asserts that
+  // the recognizer is still attached to the given view, and during dealloc
+  // UIKit may have released that association already, turning teardown into
+  // an abort. UIView teardown removes the recognizer on its own.
+  _touchHandler = nil;
+}
+
+@end

package/ios/PortalHostView.h

@@ -0,0 +1,39 @@
+//
+//  PortalHostView.h
+//  Pods
+//
+//  Created by Kiryl Ziusko on 02/09/2025.
+//
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef PortalHostViewNativeComponent_h
+#define PortalHostViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PortalHostView : RCTViewComponentView
+
+- (void)setName:(nullable NSString *)name;
+
+/// Called on the main thread whenever teleported content subviews are added
+/// or removed. Removal notifies on the next run loop so observers read the
+/// post-removal count. Set by native host owners (PortalHostContainerView);
+/// stays nil for hosts mounted inside the React tree.
+@property (nonatomic, copy, nullable) void (^onSubviewCountChanged)(void);
+
+/// Returns the index at which a portal child should be inserted.
+///
+/// Within a single Fabric commit all mutations run synchronously on the main
+/// thread.  The first call in a commit records the current subview count as
+/// the "base"; subsequent calls in the same commit reuse that base so that
+/// bottom-to-top Fabric ordering is compensated by `insertSubview:atIndex:`.
+/// A `dispatch_async` resets the flag after the commit finishes.
+- (NSInteger)nextInsertionIndexForChildAt:(NSInteger)childIndex;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* PortalHostViewNativeComponent_h */

package/ios/PortalHostView.mm

@@ -0,0 +1,153 @@
+//
+//  PortalHostView.mm
+//  Pods
+//
+//  Created by Kiryl Ziusko on 02/09/2025.
+//
+
+#import "PortalHostView.h"
+#import "PortalRegistry.h"
+
+#import <react/renderer/components/GraniteMicroFrontendRuntimeSpec/EventEmitters.h>
+#import <react/renderer/components/GraniteMicroFrontendRuntimeSpec/Props.h>
+#import <react/renderer/components/GraniteMicroFrontendRuntimeSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/GraniteMicroFrontendRuntimeSpec/RNTPortalHostViewComponentDescriptor.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface PortalHostView () <RCTPortalHostViewViewProtocol>
+
+@property (nonatomic, strong) NSString *registeredName;
+@property (nonatomic, assign) BOOL isInBatch;
+@property (nonatomic, assign) NSInteger batchBaseIndex;
+
+@end
+
+@implementation PortalHostView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<PortalHostViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const PortalHostViewProps>();
+    _props = defaultProps;
+  }
+
+  return self;
+}
+
+- (void)setName:(nullable NSString *)name
+{
+  if ([self.registeredName isEqualToString:name]) {
+    return;
+  }
+
+  if (self.registeredName) {
+    [[PortalRegistry sharedInstance] unregisterHost:self withName:self.registeredName];
+  }
+  self.registeredName = name;
+  if (name) {
+    [[PortalRegistry sharedInstance] registerHost:self withName:name];
+  }
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (!self.registeredName) {
+    return;
+  }
+  if (self.window) {
+    [[PortalRegistry sharedInstance] registerHost:self withName:self.registeredName];
+  } else {
+    [[PortalRegistry sharedInstance] unregisterHost:self withName:self.registeredName];
+  }
+}
+
+- (void)didAddSubview:(UIView *)subview
+{
+  [super didAddSubview:subview];
+  if (self.onSubviewCountChanged) {
+    self.onSubviewCountChanged();
+  }
+}
+
+- (void)willRemoveSubview:(UIView *)subview
+{
+  [super willRemoveSubview:subview];
+  if (!self.onSubviewCountChanged) {
+    return;
+  }
+  // Notify on the next run loop so observers read the post-removal count.
+  __weak PortalHostView *weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    PortalHostView *strongSelf = weakSelf;
+    if (strongSelf && strongSelf.onSubviewCountChanged) {
+      strongSelf.onSubviewCountChanged();
+    }
+  });
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &newViewProps = *std::static_pointer_cast<PortalHostViewProps const>(props);
+
+  std::string nameStr = newViewProps.name;
+  NSString *newName = nameStr.empty() ? nil : [NSString stringWithUTF8String:nameStr.c_str()];
+  [self setName:newName];
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+
+  if (self.registeredName) {
+    [[PortalRegistry sharedInstance] notifyHostLayoutChangedWithName:self.registeredName];
+  }
+}
+
+- (NSInteger)nextInsertionIndexForChildAt:(NSInteger)childIndex
+{
+  if (!self.isInBatch) {
+    self.isInBatch = YES;
+    self.batchBaseIndex = (NSInteger)self.subviews.count;
+    __weak PortalHostView *weakSelf = self;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      weakSelf.isInBatch = NO;
+    });
+  }
+  return MIN(self.batchBaseIndex + childIndex, (NSInteger)self.subviews.count);
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+
+  self.isInBatch = NO;
+  self.batchBaseIndex = 0;
+
+  [self setName:nil];
+}
+
+- (void)dealloc
+{
+  if (self.registeredName) {
+    [[PortalRegistry sharedInstance] unregisterHost:self withName:self.registeredName];
+  }
+}
+
+Class<RCTComponentViewProtocol> PortalHostViewCls(void)
+{
+  return PortalHostView.class;
+}
+
+@end

package/ios/PortalRegistry.h

@@ -0,0 +1,38 @@
+//
+//  PortalRegistry.h
+//  Pods
+//
+//  Created by Kiryl Ziusko on 04/09/2025.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class PortalHostView;
+@class PortalView;
+
+/**
+ * Main-thread-only registry that joins Portal destinations to Portal views.
+ *
+ * Multiple hosts may share one name; resolve prefers the last registered host in
+ * the same window as the portal source, otherwise the last registered host that
+ * still has a window.
+ */
+@interface PortalRegistry : NSObject
+
++ (instancetype)sharedInstance;
+
+- (void)registerHost:(PortalHostView *)host withName:(NSString *)name;
+- (void)unregisterHost:(PortalHostView *)host withName:(NSString *)name;
+- (nullable PortalHostView *)resolveHostWithName:(nullable NSString *)name
+                                      sourceView:(UIView *)sourceView;
+- (void)notifyHostLayoutChangedWithName:(NSString *)name;
+
+- (void)registerPendingPortal:(PortalView *)portal withHostName:(NSString *)hostName;
+- (void)unregisterPendingPortal:(PortalView *)portal withHostName:(NSString *)hostName;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/PortalRegistry.mm

@@ -0,0 +1,228 @@
+//
+//  PortalRegistry.m
+//  Pods
+//
+//  Created by Kiryl Ziusko on 04/09/2025.
+//
+
+#import "PortalRegistry.h"
+#import "PortalHostView.h"
+#import "PortalView.h"
+
+// NSPointerArray.compact is a documented no-op for sparse weak arrays unless a
+// NULL pointer is appended first (long-standing Foundation behavior / rdar).
+static void GranitePortalCompact(NSPointerArray *array)
+{
+  if (array == nil) {
+    return;
+  }
+  [array addPointer:NULL];
+  [array compact];
+}
+
+static NSArray *GranitePortalSnapshotNonNullPointers(NSPointerArray *array)
+{
+  GranitePortalCompact(array);
+  NSMutableArray *snapshot = [NSMutableArray arrayWithCapacity:array.count];
+  for (NSUInteger i = 0; i < array.count; i++) {
+    void *pointer = [array pointerAtIndex:i];
+    if (pointer != NULL) {
+      [snapshot addObject:(__bridge id)pointer];
+    }
+  }
+  return snapshot;
+}
+
+@interface PortalRegistry ()
+
+@property (nonatomic, strong) NSMutableDictionary<NSString *, NSPointerArray *> *hosts;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, NSPointerArray *> *pendingPortals;
+
+@end
+
+@implementation PortalRegistry
+
++ (instancetype)sharedInstance
+{
+  static PortalRegistry *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[self alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _hosts = [NSMutableDictionary dictionary];
+    _pendingPortals = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (void)registerHost:(PortalHostView *)host withName:(NSString *)name
+{
+  if (!name || !host) {
+    return;
+  }
+
+  NSPointerArray *namedHosts = self.hosts[name];
+  if (!namedHosts) {
+    namedHosts = [NSPointerArray weakObjectsPointerArray];
+    self.hosts[name] = namedHosts;
+  }
+
+  GranitePortalCompact(namedHosts);
+  for (NSInteger index = (NSInteger)namedHosts.count - 1; index >= 0; index--) {
+    PortalHostView *existingHost = (__bridge PortalHostView *)[namedHosts pointerAtIndex:index];
+    if (existingHost == host) {
+      [namedHosts removePointerAtIndex:index];
+    }
+  }
+  [namedHosts addPointer:(__bridge void *)host];
+  [self notifySubscribersForName:name];
+}
+
+- (void)unregisterHost:(PortalHostView *)host withName:(NSString *)name
+{
+  if (!name || !host) {
+    return;
+  }
+
+  NSPointerArray *namedHosts = self.hosts[name];
+  if (namedHosts) {
+    for (NSInteger index = (NSInteger)namedHosts.count - 1; index >= 0; index--) {
+      PortalHostView *existingHost = (__bridge PortalHostView *)[namedHosts pointerAtIndex:index];
+      if (!existingHost || existingHost == host) {
+        [namedHosts removePointerAtIndex:index];
+      }
+    }
+    GranitePortalCompact(namedHosts);
+    if (namedHosts.count == 0) {
+      [self.hosts removeObjectForKey:name];
+    }
+  }
+  [self notifySubscribersForName:name];
+}
+
+- (void)notifySubscribersForName:(NSString *)name
+{
+  NSPointerArray *portals = self.pendingPortals[name];
+  if (!portals) {
+    return;
+  }
+
+  // Snapshot before notifying so a re-entrant register/unregister during
+  // onHostChanged cannot skip remaining subscribers.
+  NSArray *subscribers = GranitePortalSnapshotNonNullPointers(portals);
+  for (PortalView *portal in subscribers) {
+    [portal onHostChanged];
+  }
+}
+
+- (nullable PortalHostView *)resolveHostWithName:(nullable NSString *)name
+                                      sourceView:(UIView *)sourceView
+{
+  if (!name) {
+    return nil;
+  }
+
+  NSPointerArray *namedHosts = self.hosts[name];
+  if (!namedHosts) {
+    return nil;
+  }
+
+  GranitePortalCompact(namedHosts);
+  if (namedHosts.count == 0) {
+    [self.hosts removeObjectForKey:name];
+    return nil;
+  }
+
+  // Last registered host wins when multiple hosts share a name. Prefer the host
+  // in the same window as the portal source when available.
+  UIWindow *sourceWindow = sourceView.window;
+  if (sourceWindow) {
+    for (NSInteger index = (NSInteger)namedHosts.count - 1; index >= 0; index--) {
+      PortalHostView *host = (__bridge PortalHostView *)[namedHosts pointerAtIndex:index];
+      if (host.window == sourceWindow) {
+        return host;
+      }
+    }
+  }
+
+  for (NSInteger index = (NSInteger)namedHosts.count - 1; index >= 0; index--) {
+    PortalHostView *host = (__bridge PortalHostView *)[namedHosts pointerAtIndex:index];
+    if (host.window) {
+      return host;
+    }
+  }
+  return nil;
+}
+
+- (void)notifyHostLayoutChangedWithName:(NSString *)name
+{
+  if (!name) {
+    return;
+  }
+
+  NSPointerArray *portals = self.pendingPortals[name];
+  if (!portals) {
+    return;
+  }
+
+  NSArray *subscribers = GranitePortalSnapshotNonNullPointers(portals);
+  for (PortalView *portal in subscribers) {
+    [portal onHostLayoutChanged];
+  }
+}
+
+- (void)registerPendingPortal:(PortalView *)portal withHostName:(NSString *)hostName
+{
+  if (!hostName || !portal) {
+    return;
+  }
+
+  NSPointerArray *portals = self.pendingPortals[hostName];
+  if (!portals) {
+    portals = [NSPointerArray weakObjectsPointerArray];
+    self.pendingPortals[hostName] = portals;
+  }
+
+  GranitePortalCompact(portals);
+  for (NSInteger index = (NSInteger)portals.count - 1; index >= 0; index--) {
+    PortalView *existingPortal = (__bridge PortalView *)[portals pointerAtIndex:index];
+    if (existingPortal == portal) {
+      [portals removePointerAtIndex:index];
+    }
+  }
+  [portals addPointer:(__bridge void *)portal];
+}
+
+- (void)unregisterPendingPortal:(PortalView *)portal withHostName:(NSString *)hostName
+{
+  if (!hostName || !portal) {
+    return;
+  }
+
+  NSPointerArray *portals = self.pendingPortals[hostName];
+  if (!portals) {
+    return;
+  }
+
+  for (NSUInteger i = 0; i < portals.count; i++) {
+    PortalView *existingPortal = (__bridge PortalView *)[portals pointerAtIndex:i];
+    if (existingPortal == portal) {
+      [portals removePointerAtIndex:i];
+      break;
+    }
+  }
+
+  GranitePortalCompact(portals);
+  if (portals.count == 0) {
+    [self.pendingPortals removeObjectForKey:hostName];
+  }
+}
+
+@end

package/ios/PortalView.h

@@ -0,0 +1,32 @@
+//
+//  PortalView.h
+//  Pods
+//
+//  Created by Kiryl Ziusko on 02/09/2025.
+//
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef PortalViewNativeComponent_h
+#define PortalViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Fabric portal that reparents its React children under a named host.
+ *
+ * Child UIViewControllers under teleported content are reattached to the nearest
+ * parent of the destination view when content moves. Hosts that do not own a
+ * view controller will leave those children without a parent VC.
+ */
+@interface PortalView : RCTViewComponentView
+
+- (void)onHostChanged;
+- (void)onHostLayoutChanged;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* PortalViewNativeComponent_h */