zixflow-reactnative 1.0.0

package/ios/wrappers/inapp/NativeMessagingInApp.mm

@@ -0,0 +1,122 @@
+#import "../utils/RCTCustomerIOUtils.h"
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTInitializing.h>
+#import <React/RCTInvalidating.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Protocol that extends the spec with setEventEmitter method
+@protocol NativeMessagingInAppBridge <NativeCustomerIOMessagingInAppSpec, RCTInitializing, RCTInvalidating>
+- (void)setEventEmitter:(id)emitter;
+@end
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeMessagingInApp
+    : NativeCustomerIOMessagingInAppSpecBase <NativeCustomerIOMessagingInAppSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeMessagingInAppBridge> swiftBridge;
+@end
+
+@implementation RCTNativeMessagingInApp
+
+RCT_EXPORT_MODULE()
+
+// Create TurboModule instance for new architecture JSI integration
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeCustomerIOMessagingInAppSpecJSI>(params);
+}
+
+// Validates Swift bridge is available before method calls
+- (void)assertBridgeAvailable:(NSString *)context {
+  RCT_ASSERT_BRIDGE_AVAILABLE(self.swiftBridge, context);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Use runtime class lookup to avoid import issues and circular dependencies
+    Class swiftClass = NSClassFromString(@"NativeMessagingInApp");
+    RCT_ASSERT_NOT_NIL(swiftClass, @"NativeMessagingInApp Swift class", @"during runtime lookup");
+    _swiftBridge = [[swiftClass alloc] init];
+    [self assertBridgeAvailable:@"creating NativeMessagingInApp Swift instance"];
+
+    // Set event emitter reference for new architecture
+    [_swiftBridge setEventEmitter:self];
+  }
+  return self;
+}
+
+// Module initialization can happen on background thread
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)initialize {
+  [self assertBridgeAvailable:@"during initialize"];
+  [_swiftBridge initialize];
+}
+
+- (void)invalidate {
+  [self assertBridgeAvailable:@"during invalidate"];
+  [_swiftBridge invalidate];
+}
+
+- (void)dismissMessage {
+  [self assertBridgeAvailable:@"during dismissMessage"];
+  [_swiftBridge dismissMessage];
+}
+
+- (void)setupInboxListener {
+  [self assertBridgeAvailable:@"during setupInboxListener"];
+  [_swiftBridge setupInboxListener];
+}
+
+- (void)getMessages:(NSString *)topic
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  [self assertBridgeAvailable:@"during getMessages"];
+  [_swiftBridge getMessages:topic resolve:resolve reject:reject];
+}
+
+- (void)markMessageOpened:(NSDictionary *)message {
+  [self assertBridgeAvailable:@"during markMessageOpened"];
+  [_swiftBridge markMessageOpened:message];
+}
+
+- (void)markMessageUnopened:(NSDictionary *)message {
+  [self assertBridgeAvailable:@"during markMessageUnopened"];
+  [_swiftBridge markMessageUnopened:message];
+}
+
+- (void)markMessageDeleted:(NSDictionary *)message {
+  [self assertBridgeAvailable:@"during markMessageDeleted"];
+  [_swiftBridge markMessageDeleted:message];
+}
+
+- (void)trackMessageClicked:(NSDictionary *)message actionName:(NSString *)actionName {
+  [self assertBridgeAvailable:@"during trackMessageClicked"];
+  [_swiftBridge trackMessageClicked:message actionName:actionName];
+}
+
+- (void)addListener:(nonnull NSString *)eventName {
+  RCT_LEGACY_ARCH_WARNING(addListener);
+}
+
+- (void)removeListeners:(double)count {
+  RCT_LEGACY_ARCH_WARNING(removeListeners);
+}
+
+- (void)emitOnInAppEventReceived:(NSDictionary *)value {
+  [super emitOnInAppEventReceived:value];
+}
+
+- (void)emitSubscribeToMessagesChanged:(NSDictionary *)value {
+  [super emitSubscribeToMessagesChanged:value];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeCustomerIOMessagingInAppCls(void) {
+  return RCTNativeMessagingInApp.class;
+}
+
+@end

package/ios/wrappers/inapp/NativeMessagingInApp.swift

@@ -0,0 +1,214 @@
+import CioInternalCommon
+import CioMessagingInApp
+import Foundation
+import React
+
+// In-app messaging module for new React Native architecture (TurboModule)
+@objc(NativeMessagingInApp)
+public class NativeMessagingInApp: NSObject {
+    // Reference to the ObjC event emitter for new architecture (TurboModule)
+    private weak var objcEventEmitter: AnyObject?
+    private lazy var inAppEventCallback: (_ body: [String: Any]) -> Void = { [weak self] body in
+        self?.sendEvent(body: body)
+    }
+
+    private let logger: CioInternalCommon.Logger = DIGraphShared.shared.logger
+
+    // Task that consumes the inbox messages stream
+    private var messagesStreamTask: Task<Void, Never>?
+
+    // Set ObjC event emitter reference for new architecture
+    @objc
+    public func setEventEmitter(_ emitter: AnyObject) {
+        objcEventEmitter = emitter
+    }
+
+    // Initialize in-app event listener - called by React Native
+    @objc
+    public func initialize() {
+        // Initialize in-app event listener - called by React Native
+        ReactInAppEventListener.shared.setEventEmitter { [weak self] data in
+            guard let self else { return }
+
+            // Filter out nil values to convert [String: Any?] to [String: Any]
+            let body = data.compactMapValues { $0 }
+            inAppEventCallback(body)
+        }
+        // If MessagingInApp module has already been initialized, this sets the listener directly.
+        // If this method is called early, accessing ReactInAppEventListener.shared will also register
+        // it into the DI graph, making it available for access in Expo during auto-initialization.
+        MessagingInApp.shared.setEventListener(ReactInAppEventListener.shared)
+
+        // Note: Inbox change listener is set up lazily when inbox is first accessed via
+        // setupInboxListener(), not here. Notification Inbox becomes available only after
+        // CustomerIO.initialize() is called, which may not have happened yet at this point.
+    }
+
+    // Clear in-app event listener to prevent memory leaks - called by React Native
+    @objc
+    public func invalidate() {
+        // Clear in-app event listener to prevent leaks
+        clearInAppEventListener()
+        clearInboxChangeListener()
+    }
+
+    /// Dismisses any currently displayed in-app message
+    @objc(dismissMessage)
+    public func dismissMessage() {
+        MessagingInApp.shared.dismissMessage()
+    }
+
+    // MARK: - Inbox Methods
+
+    @objc(setupInboxListener)
+    public func setupInboxListener() {
+        setupInboxChangeListener()
+    }
+
+    @objc(getMessages:resolve:reject:)
+    public func getMessages(topic: String?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        guard let inbox = requireInboxInstance() else {
+            reject(
+                "INBOX_NOT_AVAILABLE",
+                "Notification Inbox is not available. Ensure CustomerIO SDK is initialized.",
+                nil
+            )
+            return
+        }
+
+        Task {
+            // Use native topic filtering - SDK handles filtering and case sensitivity
+            let messages = await inbox.getMessages(topic: topic)
+            let messagesArray = messages.map { $0.toDictionary() }
+            resolve(messagesArray)
+        }
+    }
+
+    @objc(markMessageOpened:)
+    public func markMessageOpened(message: NSDictionary) {
+        performInboxMessageAction(message: message) { inbox, inboxMessage in
+            inbox.markMessageOpened(message: inboxMessage)
+        }
+    }
+
+    @objc(markMessageUnopened:)
+    public func markMessageUnopened(message: NSDictionary) {
+        performInboxMessageAction(message: message) { inbox, inboxMessage in
+            inbox.markMessageUnopened(message: inboxMessage)
+        }
+    }
+
+    @objc(markMessageDeleted:)
+    public func markMessageDeleted(message: NSDictionary) {
+        performInboxMessageAction(message: message) { inbox, inboxMessage in
+            inbox.markMessageDeleted(message: inboxMessage)
+        }
+    }
+
+    @objc(trackMessageClicked:actionName:)
+    public func trackMessageClicked(message: NSDictionary, actionName: String?) {
+        performInboxMessageAction(message: message) { inbox, inboxMessage in
+            inbox.trackMessageClicked(message: inboxMessage, actionName: actionName)
+        }
+    }
+
+    // MARK: - Helper Methods
+
+    // Clears the in-app event listener to prevent leaks when module is deallocated or invalidated
+    func clearInAppEventListener() {
+        ReactInAppEventListener.shared.clearEventEmitter()
+    }
+
+    /// Returns inbox instance if available, nil otherwise with error logging
+    /// Note: Notification Inbox is only available after SDK is initialized
+    private func requireInboxInstance() -> NotificationInbox? {
+        guard MessagingInApp.shared.implementation != nil else {
+            logger.error("Notification Inbox is not available. Ensure CustomerIO SDK is initialized.")
+            return nil
+        }
+        return MessagingInApp.shared.inbox
+    }
+
+    /// Parses NSDictionary to InboxMessage with error logging
+    private func parseInboxMessage(from dictionary: NSDictionary) -> InboxMessage? {
+        guard let dict = dictionary as? [String: Any],
+              let inboxMessage = InboxMessageFactory.fromDictionary(dict)
+        else {
+            logger.error("Invalid message data: \(dictionary)")
+            return nil
+        }
+        return inboxMessage
+    }
+
+    /// Helper to validate inbox availability and message data before performing a message action
+    /// Returns early if inbox is unavailable or message data is invalid
+    private func performInboxMessageAction(
+        message: NSDictionary,
+        action: (NotificationInbox, InboxMessage) -> Void
+    ) {
+        guard let inbox = requireInboxInstance() else { return }
+        guard let inboxMessage = parseInboxMessage(from: message) else { return }
+        action(inbox, inboxMessage)
+    }
+
+    /// Sets up the inbox change listener to receive real-time updates.
+    /// This method can be called multiple times safely and will only set up the listener once.
+    /// Note: Inbox must be available (SDK initialized) before this can succeed.
+    private func setupInboxChangeListener() {
+        // Only set up once to avoid duplicate listeners
+        guard messagesStreamTask == nil else {
+            return
+        }
+
+        // Check if SDK is initialized before attempting setup
+        guard let inbox = requireInboxInstance() else {
+            return
+        }
+
+        // Consume messages stream asynchronously
+        messagesStreamTask = Task { [weak self] in
+            for await messages in inbox.messages(topic: nil) {
+                guard let self else { return }
+
+                // Emit messages to React Native
+                let messagesArray = messages.map { $0.toDictionary() }
+                let payload: [String: Any] = ["messages": messagesArray]
+                self.sendInboxChangeEvent(data: payload)
+            }
+        }
+    }
+
+    private func clearInboxChangeListener() {
+        // Cancel the stream consumption task - this automatically cleans up the stream
+        messagesStreamTask?.cancel()
+        messagesStreamTask = nil
+    }
+
+    private func sendInboxChangeEvent(data: [String: Any]) {
+        guard let emitter = objcEventEmitter else {
+            return
+        }
+
+        let selector = Selector(("emitSubscribeToMessagesChanged:"))
+        guard emitter.responds(to: selector) else {
+            return
+        }
+        _ = emitter.perform(selector, with: data as NSDictionary)
+    }
+
+    // Send in-app event to React Native layer using ObjC event emitter
+    private func sendEvent(body: [String: Any]) {
+        guard let emitter = objcEventEmitter else {
+            assertionFailure("NativeMessagingInApp: ObjC event emitter is nil, cannot send in-app event")
+            return
+        }
+
+        // New architecture: use injected ObjC event emitter from TurboModule
+        let selector = Selector(("emitOnInAppEventReceived:"))
+        guard emitter.responds(to: selector) else {
+            assertionFailure("ObjC event emitter does not respond to selector: emitOnInAppEventReceived:")
+            return
+        }
+        _ = emitter.perform(selector, with: body as NSDictionary)
+    }
+}

package/ios/wrappers/inapp/ReactInAppEventListener.swift

@@ -0,0 +1,74 @@
+import CioInternalCommon
+import CioMessagingInApp
+
+/**
+ * React Native bridge for Customer.io in-app messaging events.
+ * Converts native SDK events to JavaScript compatible format.
+ */
+public class ReactInAppEventListener: InAppEventListener {
+    // Shared instance for global access
+    public static let shared = ReactInAppEventListener()
+
+    private init() {
+        // Registers in DI graph so it can be accessed by Expo without using direct imports and
+        // using common import and DI graph from native iOS SDK
+        DIGraphShared.shared.override(value: self, forType: InAppEventListener.self)
+    }
+
+    // Event emitter function to send events to React Native layer
+    private var eventEmitter: (([String: Any?]) -> Void)?
+
+    // Sets the event emitter function
+    func setEventEmitter(_ emitter: (([String: Any?]) -> Void)?) {
+        eventEmitter = emitter
+    }
+
+    // Clears the event emitter to prevent memory leaks
+    func clearEventEmitter() {
+        eventEmitter = nil
+    }
+
+    // Emits an in-app message event to React Native with unified event structure
+    private func emitInAppEvent(
+        eventType: String,
+        message: InAppMessage,
+        actionValue: String? = nil,
+        actionName: String? = nil
+    ) {
+        var data: [String: Any?] = [
+            CustomerioConstants.eventType: eventType,
+            CustomerioConstants.messageId: message.messageId,
+            CustomerioConstants.deliveryId: message.deliveryId
+        ]
+
+        if let actionValue = actionValue {
+            data[CustomerioConstants.actionValue] = actionValue
+        }
+        if let actionName = actionName {
+            data[CustomerioConstants.actionName] = actionName
+        }
+
+        eventEmitter?(data)
+    }
+
+    public func messageShown(message: InAppMessage) {
+        emitInAppEvent(eventType: CustomerioConstants.messageShown, message: message)
+    }
+
+    public func messageDismissed(message: InAppMessage) {
+        emitInAppEvent(eventType: CustomerioConstants.messageDismissed, message: message)
+    }
+
+    public func errorWithMessage(message: InAppMessage) {
+        emitInAppEvent(eventType: CustomerioConstants.errorWithMessage, message: message)
+    }
+
+    public func messageActionTaken(message: InAppMessage, actionValue: String, actionName: String) {
+        emitInAppEvent(
+            eventType: CustomerioConstants.messageActionTaken,
+            message: message,
+            actionValue: actionValue,
+            actionName: actionName
+        )
+    }
+}

package/ios/wrappers/inapp/inline/InlineInAppMessageStateEvent.swift

@@ -0,0 +1,23 @@
+import Foundation
+
+/// States representing the loading and display status of inline messages.
+/// This enum mirrors TypeScript InlineMessageState enum for consistency.
+@objc enum InlineInAppMessageStateEvent: Int, CaseIterable {
+    case loadingStarted
+    case loadingFinished
+    case noMessageToDisplay
+
+    /**
+     * Returns the string representation of the state that matches TypeScript enum values.
+     */
+    var stringValue: String {
+        switch self {
+        case .loadingStarted:
+            return "LoadingStarted"
+        case .loadingFinished:
+            return "LoadingFinished"
+        case .noMessageToDisplay:
+            return "NoMessageToDisplay"
+        }
+    }
+}

package/ios/wrappers/inapp/inline/RCTInlineMessageNative.h

@@ -0,0 +1,18 @@
+// RCTViewComponentView.h transitively includes C++ code from React Native's Fabric renderer.
+// When this header is imported from an Objective-C (.h) file, certain build phases
+// (e.g., Clang dependency scanning, Swift bridging, and module indexing) parse it in
+// pure Objective-C mode, where C++ constructs are not allowed.
+//
+// Wrapping the import in `#ifdef __cplusplus` ensures it is only visible when the file
+// is compiled in Objective-C++ mode (.mm), preventing build failures.
+#ifdef __cplusplus
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTInlineMessageNative : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/wrappers/inapp/inline/RCTInlineMessageNative.mm

@@ -0,0 +1,168 @@
+#import "RCTInlineMessageNative.h"
+#import "ReactInlineMessageView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <react/renderer/components/RNZixflowSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNZixflowSpec/EventEmitters.h>
+#import <react/renderer/components/RNZixflowSpec/Props.h>
+#import <react/renderer/components/RNZixflowSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/RNZixflowSpec/ShadowNodes.h>
+
+using namespace facebook::react;
+
+/// New architecture React Native view for inline messages
+@interface RCTInlineMessageNative () <RCTInlineMessageNativeViewProtocol>
+/// Bridge to Swift ReactInlineMessageView for platform-agnostic implementation
+@property(nonatomic, strong) id bridge;
+@end
+
+@implementation RCTInlineMessageNative
+
+- (void)assertBridgeAvailable:(NSString *)context {
+  NSAssert(self.bridge != nil, @"Bridge is nil when %@", context);
+}
+
+- (instancetype)init {
+  return [self initWithFrame:CGRectZero];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _props = InlineMessageNativeShadowNode::defaultSharedProps();
+
+    Class bridgeClass = NSClassFromString(@"ReactInlineMessageView");
+    if (bridgeClass) {
+      self.bridge = [[bridgeClass alloc] initWithContainerView:self];
+      [self assertBridgeAvailable:@"creating ReactInlineMessageView bridge instance"];
+      [self.bridge setEventEmitter:self];
+    }
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &newViewProps = *std::static_pointer_cast<InlineMessageNativeProps const>(props);
+
+  [self assertBridgeAvailable:@"during updateProps"];
+  [self.bridge setupForReuse];
+
+  // On first mount Fabric passes oldProps = nullptr; apply all props unconditionally.
+  // On updates, diff against the parameter rather than _props so we never rely on
+  // the ivar's runtime type.
+  BOOL elementIdChanged = YES;
+  if (oldProps) {
+    const auto &oldViewProps = *std::static_pointer_cast<InlineMessageNativeProps const>(oldProps);
+    elementIdChanged = oldViewProps.elementId != newViewProps.elementId;
+  }
+
+  if (elementIdChanged) {
+    NSString *elementId = [NSString stringWithCString:newViewProps.elementId.c_str() encoding:NSUTF8StringEncoding];
+    [self assertBridgeAvailable:@"updating elementId prop"];
+    [self.bridge setElementId:elementId];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self assertBridgeAvailable:@"during layoutSubviews"];
+  [self.bridge updateLayout:[NSValue valueWithCGRect:self.bounds]];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self assertBridgeAvailable:@"during prepareForRecycle"];
+  [self.bridge prepareForRecycle];
+}
+
+- (void)emitOnSizeChangeEvent:(NSDictionary *)event {
+  [self handleOnSizeChangeEvent:event];
+}
+
+- (void)emitOnStateChangeEvent:(NSDictionary *)event {
+  [self handleOnStateChangeEvent:event];
+}
+
+- (void)emitOnActionClickEvent:(NSDictionary *)event {
+  [self handleOnActionClickEvent:event];
+}
+
+- (void)handleOnSizeChangeEvent:(NSDictionary *)event {
+  if (_eventEmitter) {
+    InlineMessageNativeEventEmitter::OnSizeChange result = InlineMessageNativeEventEmitter::OnSizeChange{};
+
+    if (event[@"width"]) {
+      result.width = [event[@"width"] doubleValue];
+    }
+    if (event[@"height"]) {
+      result.height = [event[@"height"] doubleValue];
+    }
+    if (event[@"duration"]) {
+      result.duration = [event[@"duration"] doubleValue];
+    }
+
+    self.eventEmitter.onSizeChange(result);
+  }
+}
+
+- (void)handleOnStateChangeEvent:(NSDictionary *)event {
+  if (_eventEmitter) {
+    InlineMessageNativeEventEmitter::OnStateChange result = InlineMessageNativeEventEmitter::OnStateChange{};
+
+    if (event[@"state"]) {
+      result.state = std::string([[event[@"state"] description] UTF8String]);
+    }
+
+    self.eventEmitter.onStateChange(result);
+  }
+}
+
+- (void)handleOnActionClickEvent:(NSDictionary *)event {
+  if (_eventEmitter) {
+    InlineMessageNativeEventEmitter::OnActionClick result = InlineMessageNativeEventEmitter::OnActionClick{};
+
+    if (event[@"message"]) {
+      NSDictionary *message = event[@"message"];
+      InlineMessageNativeEventEmitter::OnActionClickMessage messageStruct =
+          InlineMessageNativeEventEmitter::OnActionClickMessage{};
+
+      if (message[@"messageId"]) {
+        messageStruct.messageId = std::string([[message[@"messageId"] description] UTF8String]);
+      }
+      if (message[@"deliveryId"] && message[@"deliveryId"] != [NSNull null]) {
+        messageStruct.deliveryId = std::string([[message[@"deliveryId"] description] UTF8String]);
+      }
+      if (message[@"elementId"] && message[@"elementId"] != [NSNull null]) {
+        messageStruct.elementId = std::string([[message[@"elementId"] description] UTF8String]);
+      }
+
+      result.message = messageStruct;
+    }
+
+    if (event[@"actionValue"]) {
+      result.actionValue = std::string([[event[@"actionValue"] description] UTF8String]);
+    }
+    if (event[@"actionName"]) {
+      result.actionName = std::string([[event[@"actionName"] description] UTF8String]);
+    }
+
+    self.eventEmitter.onActionClick(result);
+  }
+}
+
+// Event emitter convenience method
+- (const InlineMessageNativeEventEmitter &)eventEmitter {
+  return static_cast<const InlineMessageNativeEventEmitter &>(*_eventEmitter);
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<InlineMessageNativeComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> InlineMessageNativeCls(void) {
+  return RCTInlineMessageNative.class;
+}

package/ios/wrappers/inapp/inline/ReactInlineMessageView.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+
+@class UIView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Objective-C header for Swift ReactInlineMessageView class.
+ *
+ * This header provides a forward declaration for Swift interop without requiring
+ * Swift module headers, which can cause compilation issues in mixed static/dynamic
+ * linking configurations (e.g., FCM vs APN push providers).
+ *
+ * The actual Swift implementation is in ReactInlineMessageView.swift.
+ * This header provides method declarations for compile-time safety while using
+ * runtime class resolution (NSClassFromString) for the Swift bridge.
+ */
+
+/// Forward declaration of ReactInlineMessageView Swift class
+@interface ReactInlineMessageView : NSObject
+
+/// Initializes the view with a container view
+- (instancetype)initWithContainerView:(UIView *)containerView;
+
+/// Sets the event emitter for React Native communication
+- (void)setEventEmitter:(id)eventEmitter;
+
+/// Sets the element ID for the inline message
+- (void)setElementId:(NSString *)elementId;
+
+/// Prepares the view for reuse in React Native lifecycle
+- (void)setupForReuse;
+
+/// Updates the view layout with new bounds
+- (void)updateLayout:(NSValue *)boundsValue;
+
+/// Prepares the view for recycling
+- (void)prepareForRecycle;
+
+@end
+
+NS_ASSUME_NONNULL_END