react-native-list 1.0.0 → 2.0.0-alpha.1

package/ios/Utils/TurboModuleInstaller.mm

@@ -0,0 +1,267 @@
+#import "TurboModuleInstaller.h"
+#import "SurfacePresenterRegistry.h"
+#import "WorkletsUiCallInvoker.hpp"
+#import "ErrorUtils.h"
+#import "HybridUiManagerHelper.hpp"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTBridgeModuleDecorator.h>
+#import <React/RCTBridgeProxy.h>
+#import <React/RCTBridgeProxy+Cxx.h>
+#import <React/RCTScheduler.h>
+#import <React/RCTSurfacePresenter.h>
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+#import <worklets/apple/AssertJavaScriptQueue.h>
+#import <worklets/apple/WorkletsModule.h>
+#import <NitroModules/NitroLogger.hpp>
+
+#include <jsi/jsi.h>
+#include <react/utils/jsi-utils.h>
+
+using namespace facebook;
+using namespace facebook::react;
+using namespace worklets;
+
+namespace {
+
+static RCTTurboModuleManager *sUiTurboModuleManager = nil;
+static uint64_t sInstalledRuntimeId = 0;
+static BOOL sHasInstalledRuntime = NO;
+static std::shared_ptr<facebook::react::CallInvoker> uiCallInvoker = nullptr;
+
+} // namespace
+
+@interface HybridWorkletsModuleProxyHolderBox ()
+
+- (instancetype)initWithWorkletsModuleProxy:(std::shared_ptr<WorkletsModuleProxy>)workletsModuleProxy;
+- (std::shared_ptr<WorkletsModuleProxy>)workletsModuleProxy;
+
+@end
+
+@implementation HybridWorkletsModuleProxyHolderBox {
+  std::shared_ptr<WorkletsModuleProxy> _workletsModuleProxy;
+}
+
+- (instancetype)initWithWorkletsModuleProxy:(std::shared_ptr<WorkletsModuleProxy>)workletsModuleProxy
+{
+  self = [super init];
+  if (self != nil) {
+    _workletsModuleProxy = std::move(workletsModuleProxy);
+  }
+  return self;
+}
+
+- (std::shared_ptr<WorkletsModuleProxy>)workletsModuleProxy
+{
+  return _workletsModuleProxy;
+}
+
+@end
+
+@implementation TurboModuleInstaller
+
++ (nullable HybridWorkletsModuleProxyHolderBox *)createWorkletsModuleProxyHolder:
+    (NSError *__autoreleasing _Nullable * _Nullable)error
+{
+  @try {
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge == nil) {
+      assignError(error, @"Could not access RCTBridge.currentBridge.");
+      return nil;
+    }
+
+    if (!IsJavaScriptQueue()) {
+      assignError(error, @"iosGetWorkletsModule() must run on the JavaScript queue.");
+      return nil;
+    }
+
+    // Prime the registry module while we're on the JS queue.
+    id registryModule = [bridge moduleForClass:SurfacePresenterRegistry.class];
+    if (registryModule == nil) {
+      assignError(error, @"Could not initialize HybridUiListSurfacePresenterRegistry.");
+      return nil;
+    }
+    if ([SurfacePresenterRegistry currentSurfacePresenter] == nil) {
+      assignError(error, @"SurfacePresenter was not injected into HybridUiListSurfacePresenterRegistry.");
+      return nil;
+    }
+
+    WorkletsModule *workletsModule = [bridge moduleForClass:WorkletsModule.class];
+    if (workletsModule == nil) {
+      assignError(error, @"WorkletsModule is not available from the bridge.");
+      return nil;
+    }
+
+    std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy = [workletsModule getWorkletsModuleProxy];
+    if (workletsModuleProxy == nullptr) {
+      assignError(error, @"Could not access WorkletsModuleProxy.");
+      return nil;
+    }
+
+    return [[HybridWorkletsModuleProxyHolderBox alloc] initWithWorkletsModuleProxy:std::move(workletsModuleProxy)];
+  } @catch (NSException *exception) {
+    assignError(error, [NSString stringWithFormat:@"Failed to create WorkletsModuleProxy holder: %@", exception.reason]);
+    return nil;
+  }
+}
+
++ (BOOL)installNativeModuleProxyInUIRuntimeWithHolder:(HybridWorkletsModuleProxyHolderBox *)holder
+                                                 error:(NSError *__autoreleasing _Nullable * _Nullable)error
+{
+  @try {
+      margelo::nitro::Logger::log(margelo::nitro::LogLevel::Debug, "TurboModuleInstaller", "installNativeModuleProxyInUIRuntime()");
+    if (holder == nil) {
+      assignError(error, @"Expected non-null IOSWorkletsModuleProxyHolder.");
+      return NO;
+    }
+
+    std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy = [holder workletsModuleProxy];
+    if (workletsModuleProxy == nullptr) {
+      assignError(error, @"IOSWorkletsModuleProxyHolder does not contain a WorkletsModuleProxy.");
+      return NO;
+    }
+
+    std::shared_ptr<UIScheduler> uiScheduler = workletsModuleProxy->getUIScheduler();
+    if (uiScheduler == nullptr) {
+      assignError(error, @"Could not access UIScheduler from WorkletsModuleProxy.");
+      return NO;
+    }
+
+    std::shared_ptr<WorkletRuntime> uiWorkletRuntime = workletsModuleProxy->getUIWorkletRuntime();
+    if (uiWorkletRuntime == nullptr) {
+      assignError(error, @"Could not access UIWorkletRuntime from WorkletsModuleProxy.");
+      return NO;
+    }
+
+    uint64_t runtimeId = uiWorkletRuntime->getRuntimeId();
+    if (sHasInstalledRuntime && sInstalledRuntimeId == runtimeId) {
+      return YES;
+    }
+
+    bool hasNativeModuleProxy = false;
+    uiWorkletRuntime->runSync([&](jsi::Runtime &runtime) {
+      // We first have to set this to be bridgeless too
+      // TODO: upstream this to worklets to set this for their runtime if the JS runtime is bridgeless
+      // Note: do i want to make this xplat? have the same code dupe in android
+      if (!runtime.global().hasProperty(runtime, "RN$Bridgeless")) {
+        react::defineReadOnlyGlobal(runtime, "RN$Bridgeless", jsi::Value(true));
+      }
+      
+      jsi::Value proxy = runtime.global().getProperty(runtime, "nativeModuleProxy");
+      hasNativeModuleProxy = !proxy.isUndefined() && !proxy.isNull();
+    });
+    if (hasNativeModuleProxy) {
+      sHasInstalledRuntime = YES;
+      sInstalledRuntimeId = runtimeId;
+      return YES;
+    }
+
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge == nil) {
+      assignError(error, @"Could not access RCTBridge.currentBridge.");
+      return NO;
+    }
+
+    RCTModuleRegistry *moduleRegistry = [bridge moduleRegistry];
+    if (moduleRegistry == nil) {
+      assignError(error, @"Could not access moduleRegistry from the bridge.");
+      return NO;
+    }
+
+    id turboModuleRegistry = [moduleRegistry valueForKey:@"_turboModuleRegistry"];
+    if (![turboModuleRegistry isKindOfClass:[RCTTurboModuleManager class]]) {
+      assignError(error, @"moduleRegistry does not contain an active RCTTurboModuleManager.");
+      return NO;
+    }
+
+    RCTTurboModuleManager *rootTurboModuleManager = (RCTTurboModuleManager *)turboModuleRegistry;
+    id<RCTTurboModuleManagerDelegate> delegate = [rootTurboModuleManager valueForKey:@"_delegate"];
+    if (delegate == nil) {
+      assignError(error, @"Could not access RCTTurboModuleManager delegate.");
+      return NO;
+    }
+
+    RCTBridgeProxy *bridgeProxy = [rootTurboModuleManager valueForKey:@"_bridgeProxy"];
+    if (bridgeProxy == nil && [bridge isKindOfClass:[RCTBridgeProxy class]]) {
+      bridgeProxy = (RCTBridgeProxy *)bridge;
+    }
+    if (bridgeProxy == nil) {
+      assignError(error, @"Could not access RCTBridgeProxy.");
+      return NO;
+    }
+
+    RCTBridgeModuleDecorator *bridgeModuleDecorator = [rootTurboModuleManager valueForKey:@"_bridgeModuleDecorator"];
+    if (bridgeModuleDecorator == nil) {
+      assignError(error, @"Could not access RCTBridgeModuleDecorator.");
+      return NO;
+    }
+
+    uiCallInvoker = std::make_shared<margelo::nitro::reactnativelist::WorkletsUiCallInvoker>(uiScheduler, uiWorkletRuntime, []() {
+        return [NSThread isMainThread];
+    });
+
+    RCTTurboModuleManager *uiTurboModuleManager = [[RCTTurboModuleManager alloc] initWithBridgeProxy:bridgeProxy
+                                                           bridgeModuleDecorator:bridgeModuleDecorator
+                                                                        delegate:delegate
+                                                                       jsInvoker:uiCallInvoker];
+    if (uiTurboModuleManager == nil) {
+      assignError(error, @"Failed to create a UI-runtime RCTTurboModuleManager.");
+      return NO;
+    }
+
+      margelo::nitro::Logger::log(margelo::nitro::LogLevel::Debug, "TurboModuleInstaller", "schedule install JSI bindings!");
+    uiWorkletRuntime->runSync([uiTurboModuleManager](jsi::Runtime &runtime) {
+      [uiTurboModuleManager installJSBindings:runtime];
+        margelo::nitro::Logger::log(margelo::nitro::LogLevel::Debug, "TurboModuleInstaller", "installed JSI bindings!");
+    });
+
+    sUiTurboModuleManager = uiTurboModuleManager;
+    sHasInstalledRuntime = YES;
+    sInstalledRuntimeId = runtimeId;
+    return YES;
+  } @catch (NSException *exception) {
+    assignError(error, [NSString stringWithFormat:@"TurboModule install failed with NSException: %@", exception.reason]);
+    return NO;
+  }
+}
+
++ (BOOL)setupEventInterceptor:(NSError *__autoreleasing _Nullable * _Nullable)error {
+  @try {
+    if (uiCallInvoker == nullptr) {
+      assignError(error, @"UI CallInvoker must be initialized before setting up event interceptor.");
+      return NO;
+    }
+
+    id surfacePresenterObj = [SurfacePresenterRegistry currentSurfacePresenter];
+    if (surfacePresenterObj == nil) {
+      assignError(error, @"SurfacePresenter from SurfacePresenterRegistry was null!");
+      return NO;
+    }
+
+    if (![surfacePresenterObj isKindOfClass:[RCTSurfacePresenter class]]) {
+      assignError(error, @"SurfacePresenterRegistry did not return an RCTSurfacePresenter instance.");
+      return NO;
+    }
+
+    RCTSurfacePresenter *surfacePresenter = (RCTSurfacePresenter *)surfacePresenterObj;
+    RCTScheduler *scheduler = surfacePresenter.scheduler;
+    if (scheduler == nil) {
+      assignError(error, @"Could not access an active RCTScheduler from the current RCTSurfacePresenter.");
+      return NO;
+    }
+
+    std::shared_ptr<EventListener> eventInterceptor =
+        margelo::nitro::reactnativelist::HybridUiManagerHelper::createEventInterceptor(uiCallInvoker);
+    [scheduler addEventListener:eventInterceptor];
+
+    return YES;
+  } @catch (NSException *exception) {
+    assignError(error, [NSString stringWithFormat:@"Event interceptor setup failed with NSException: %@", exception.reason]);
+    return NO;
+  }
+}
+
+@end

package/ios/Views/HostCell.swift

@@ -0,0 +1,216 @@
+import UIKit
+
+final class HostCell: UICollectionViewCell {
+
+    private var hostedView: UIView?
+    private var topConstraint: NSLayoutConstraint?
+    private var leadingConstraint: NSLayoutConstraint?
+    private var widthConstraint: NSLayoutConstraint?
+    private var heightConstraint: NSLayoutConstraint?
+
+    var reactTag: Int?
+    var itemKey: String?
+    var itemType: String?
+    var hostedContentView: UIView? {
+        return hostedView
+    }
+
+    func install(
+        view: UIView,
+        contentSize: CGSize,
+        contentInset: UIEdgeInsets,
+        itemKey: String,
+        itemType: String
+    ) {
+        if let currentHostedView = hostedView {
+            let isCurrentViewOwnedByCell = currentHostedView.superview === contentView
+            if isCurrentViewOwnedByCell {
+                deactivateInstalledConstraints(for: currentHostedView)
+                currentHostedView.removeFromSuperview()
+            }
+        }
+
+        deactivateInstalledConstraints(for: view)
+        view.removeFromSuperview()
+
+        hostedView = view
+        self.itemKey = itemKey
+        self.itemType = itemType
+
+        view.translatesAutoresizingMaskIntoConstraints = false
+        contentView.addSubview(view)
+
+        let widthConstraint = view.widthAnchor.constraint(equalToConstant: contentSize.width)
+        let heightConstraint = view.heightAnchor.constraint(equalToConstant: contentSize.height)
+        let topConstraint = view.topAnchor.constraint(
+            equalTo: contentView.topAnchor,
+            constant: contentInset.top
+        )
+        let leadingConstraint = view.leadingAnchor.constraint(
+            equalTo: contentView.leadingAnchor,
+            constant: contentInset.left
+        )
+        self.topConstraint = topConstraint
+        self.leadingConstraint = leadingConstraint
+        self.widthConstraint = widthConstraint
+        self.heightConstraint = heightConstraint
+
+        NSLayoutConstraint.activate([
+            topConstraint,
+            leadingConstraint,
+            widthConstraint,
+            heightConstraint,
+        ])
+    }
+
+    func bind(itemKey: String) {
+        self.itemKey = itemKey
+    }
+
+    func prepareForMeasurement(width: CGFloat, height: CGFloat?) {
+        // Text-like rows need a concrete width to wrap before we can measure natural height.
+        setWidthConstraint(width)
+
+        if let height {
+            setHeightConstraint(height)
+        } else {
+            deactivateHeightConstraint()
+        }
+    }
+
+    func updateContentLayout(contentSize: CGSize, contentInset: UIEdgeInsets) {
+        setTopConstraint(contentInset.top)
+        setLeadingConstraint(contentInset.left)
+        setWidthConstraint(contentSize.width)
+        setHeightConstraint(contentSize.height)
+    }
+
+    func detachHostedView() {
+        if let hostedView {
+            let isHostedViewOwnedByCell = hostedView.superview === contentView
+            if isHostedViewOwnedByCell {
+                deactivateInstalledConstraints(for: hostedView)
+                hostedView.removeFromSuperview()
+            }
+        }
+
+        hostedView = nil
+        reactTag = nil
+        itemKey = nil
+        itemType = nil
+        topConstraint = nil
+        leadingConstraint = nil
+        widthConstraint = nil
+        heightConstraint = nil
+    }
+
+    override func prepareForReuse() {
+        super.prepareForReuse()
+        itemKey = nil
+        if let hostedView {
+            contentView.bringSubviewToFront(hostedView)
+        }
+    }
+
+    private func deactivateInstalledConstraints(for view: UIView) {
+        let localConstraints = view.constraints.filter { constraint in
+            let isWidthConstraint = constraint.firstAttribute == .width
+            let isHeightConstraint = constraint.firstAttribute == .height
+            let isSizeConstraint = isWidthConstraint || isHeightConstraint
+            let firstView = constraint.firstItem as? UIView
+            let isOwnedByView = firstView === view
+            let isLocalConstraint = constraint.secondItem == nil
+            return isSizeConstraint && isOwnedByView && isLocalConstraint
+        }
+        NSLayoutConstraint.deactivate(localConstraints)
+
+        guard let superview = view.superview else { return }
+
+        let parentConstraints = superview.constraints.filter { constraint in
+            let firstView = constraint.firstItem as? UIView
+            let secondView = constraint.secondItem as? UIView
+            let usesFirstView = firstView === view
+            let usesSecondView = secondView === view
+            return usesFirstView || usesSecondView
+        }
+        NSLayoutConstraint.deactivate(parentConstraints)
+    }
+
+    private func setWidthConstraint(_ width: CGFloat) {
+        if let widthConstraint {
+            widthConstraint.constant = width
+            if !widthConstraint.isActive {
+                widthConstraint.isActive = true
+            }
+            return
+        }
+
+        guard let hostedView else { return }
+        let widthConstraint = hostedView.widthAnchor.constraint(equalToConstant: width)
+        self.widthConstraint = widthConstraint
+        widthConstraint.isActive = true
+    }
+
+    private func setTopConstraint(_ topInset: CGFloat) {
+        if let topConstraint {
+            topConstraint.constant = topInset
+            if !topConstraint.isActive {
+                topConstraint.isActive = true
+            }
+            return
+        }
+
+        guard let hostedView else { return }
+        let topConstraint = hostedView.topAnchor.constraint(
+            equalTo: contentView.topAnchor,
+            constant: topInset
+        )
+        self.topConstraint = topConstraint
+        topConstraint.isActive = true
+    }
+
+    private func setLeadingConstraint(_ leadingInset: CGFloat) {
+        if let leadingConstraint {
+            leadingConstraint.constant = leadingInset
+            if !leadingConstraint.isActive {
+                leadingConstraint.isActive = true
+            }
+            return
+        }
+
+        guard let hostedView else { return }
+        let leadingConstraint = hostedView.leadingAnchor.constraint(
+            equalTo: contentView.leadingAnchor,
+            constant: leadingInset
+        )
+        self.leadingConstraint = leadingConstraint
+        leadingConstraint.isActive = true
+    }
+
+    private func setHeightConstraint(_ height: CGFloat) {
+        if let heightConstraint {
+            heightConstraint.constant = height
+            if !heightConstraint.isActive {
+                heightConstraint.isActive = true
+            }
+            return
+        }
+
+        guard let hostedView else { return }
+        let heightConstraint = hostedView.heightAnchor.constraint(equalToConstant: height)
+        self.heightConstraint = heightConstraint
+        heightConstraint.isActive = true
+    }
+
+    private func deactivateWidthConstraint() {
+        guard let widthConstraint else { return }
+        widthConstraint.isActive = false
+        self.widthConstraint = nil
+    }
+
+    private func deactivateHeightConstraint() {
+        guard let heightConstraint else { return }
+        heightConstraint.isActive = false
+        self.heightConstraint = nil
+    }
+}