zixflow-reactnative 1.1.3 → 1.1.5

package/ios/wrappers/inapp/NativeMessagingInApp.mm

@@ -66,11 +66,29 @@ RCT_EXPORT_MODULE(NativeZixflowMessagingInApp)
   [_swiftBridge dismissMessage];
 }
 
+// Signature matches the Codegen protocol, which declares the argument nonnull. ObjC does not
+// enforce that at runtime, so a JavaScript null still arrives here as nil and is forwarded; the
+// Swift side takes an optional and reports it rather than trapping.
+- (void)setColorScheme:(NSString *)colorScheme {
+  [self assertBridgeAvailable:@"during setColorScheme"];
+  [_swiftBridge setColorScheme:colorScheme];
+}
+
 - (void)setupInboxListener {
   [self assertBridgeAvailable:@"during setupInboxListener"];
   [_swiftBridge setupInboxListener];
 }
 
+- (void)registerInboxEventListener {
+  [self assertBridgeAvailable:@"during registerInboxEventListener"];
+  [_swiftBridge registerInboxEventListener];
+}
+
+- (void)unregisterInboxEventListener {
+  [self assertBridgeAvailable:@"during unregisterInboxEventListener"];
+  [_swiftBridge unregisterInboxEventListener];
+}
+
 - (void)getMessages:(NSString *)topic
             resolve:(RCTPromiseResolveBlock)resolve
              reject:(RCTPromiseRejectBlock)reject {
@@ -110,6 +128,10 @@ RCT_EXPORT_MODULE(NativeZixflowMessagingInApp)
   [super emitOnInAppEventReceived:value];
 }
 
+- (void)emitOnInboxEventReceived:(NSDictionary *)value {
+  [super emitOnInboxEventReceived:value];
+}
+
 - (void)emitSubscribeToMessagesChanged:(NSDictionary *)value {
   [super emitSubscribeToMessagesChanged:value];
 }

package/ios/wrappers/inapp/NativeMessagingInApp.swift

@@ -2,6 +2,7 @@ import ZixflowInternalCommon
 import ZixflowMessagingInApp
 import Foundation
 import React
+import SwiftUI
 
 // In-app messaging module for new React Native architecture (TurboModule)
 @objc(NativeZixflowMessagingInApp)
@@ -50,6 +51,48 @@ public class NativeMessagingInApp: NSObject {
         // Clear in-app event listener to prevent leaks
         clearInAppEventListener()
         clearInboxChangeListener()
+        clearInboxEventListener()
+    }
+
+    // MARK: - Inbox Event Listener
+
+    /// Registers the native inbox event forwarder with the SDK and wires it to the ObjC event
+    /// emitter. Called by React Native when a JS inbox event listener is registered.
+    @objc(registerInboxEventListener)
+    public func registerInboxEventListener() {
+        ReactInboxEventListener.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 }
+            self.sendInboxEvent(body: body)
+        }
+        MessagingInApp.shared.setInboxEventListener(ReactInboxEventListener.shared)
+    }
+
+    /// Unregisters the native inbox event forwarder from the SDK, restoring the SDK's default action
+    /// handling. Called by React Native when the JS inbox event listener is removed.
+    @objc(unregisterInboxEventListener)
+    public func unregisterInboxEventListener() {
+        MessagingInApp.shared.setInboxEventListener(nil)
+        ReactInboxEventListener.shared.clearEventEmitter()
+    }
+
+    private func clearInboxEventListener() {
+        MessagingInApp.shared.setInboxEventListener(nil)
+        ReactInboxEventListener.shared.clearEventEmitter()
+    }
+
+    // Send inbox event to React Native layer using ObjC event emitter
+    private func sendInboxEvent(body: [String: Any]) {
+        guard let emitter = objcEventEmitter else {
+            return
+        }
+
+        let selector = Selector(("emitOnInboxEventReceived:"))
+        guard emitter.responds(to: selector) else {
+            return
+        }
+        _ = emitter.perform(selector, with: body as NSDictionary)
     }
 
     /// Dismisses any currently displayed in-app message
@@ -58,6 +101,54 @@ public class NativeMessagingInApp: NSObject {
         MessagingInApp.shared.dismissMessage()
     }
 
+    /// Overrides the color scheme used to render in-app messages.
+    ///
+    /// Receives the raw value of the JavaScript `ZixflowColorScheme`, since the enum itself cannot
+    /// cross Codegen. An unrecognized value leaves the current scheme alone instead of resetting
+    /// it to `.auto`, so a typo cannot quietly undo a scheme the app set correctly earlier — the
+    /// Android bridge behaves the same way.
+    ///
+    /// The parameter is optional even though Codegen declares it non-null: untyped JavaScript can
+    /// still pass `null` or `undefined`, which the bridge forwards as `nil`. Bridging that into a
+    /// non-optional `String` would trap before the value could be reported, and Android accepts a
+    /// nullable argument for the same reason, so a non-optional type here would also leave the two
+    /// platforms behaving differently on the same input.
+    @objc(setColorScheme:)
+    public func setColorScheme(_ colorScheme: String?) {
+        guard let resolved = Self.colorScheme(fromRawValue: colorScheme) else {
+            logger.error(
+                "Unrecognized in-app colorScheme '\(colorScheme ?? "nil")', expected one of auto, light, dark. Leaving the color scheme unchanged."
+            )
+            return
+        }
+        // Without this the call is dropped in silence: `setColorScheme` forwards through the
+        // module's `implementation?`, which is nil until the SDK is initialized, and the only
+        // trace is an `.info` line the default `.error` log level discards. Android logs this
+        // case at error, so reporting it here is what keeps the two platforms diagnosable in the
+        // same way. Logged rather than failed, again to match Android, which completes the call.
+        guard MessagingInApp.shared.hasBeenInitialized else {
+            logger.error(
+                "In-app messaging is not available, so the color scheme was not applied. Ensure Zixflow SDK is initialized with the inApp configuration."
+            )
+            return
+        }
+        MessagingInApp.shared.setColorScheme(resolved)
+    }
+
+    /// Maps the wrapper's lowercase wire value onto the native `ColorScheme`.
+    ///
+    /// Matched explicitly rather than handed to `MessagingInAppConfigBuilder`, which resolves
+    /// anything unrecognized to `.auto`; here an unrecognized value has to stay distinguishable
+    /// so it can be reported.
+    private static func colorScheme(fromRawValue rawValue: String?) -> ColorScheme? {
+        switch rawValue {
+        case "auto": return .auto
+        case "light": return .light
+        case "dark": return .dark
+        default: return nil
+        }
+    }
+
     // MARK: - Inbox Methods
 
     @objc(setupInboxListener)

package/ios/wrappers/inbox/InboxHostContainment.swift

@@ -0,0 +1,40 @@
+import Foundation
+import UIKit
+
+/// Shared view-controller containment for the inbox `UIHostingController` hosts.
+///
+/// Adopting only a hosting controller's `view` leaves the controller outside the view-controller
+/// hierarchy. UIKit then has no presentation context or trait/safe-area chain for it, which showed up
+/// as a phantom top margin in the overlay's sheet (the sheet content resolved insets against the
+/// wrong container) and means no lifecycle callbacks ever reach the hosted SwiftUI. Native usage does
+/// not hit this because there the hosting controller *is* a real pushed view controller.
+///
+/// Containment has to be deferred until the Fabric view is actually in a window: React Native creates
+/// component views before mounting them, so at `init` there is no parent controller to attach to.
+enum InboxHostContainment {
+    /// Nearest view controller up the responder chain, or nil while the view is unmounted.
+    static func nearestViewController(from view: UIView?) -> UIViewController? {
+        var responder: UIResponder? = view
+        while let current = responder {
+            if let viewController = current as? UIViewController {
+                return viewController
+            }
+            responder = current.next
+        }
+        return nil
+    }
+
+    /// Attaches `child` to the controller owning `view`. No-op when already attached or unmounted.
+    static func attach(_ child: UIViewController, hostedIn view: UIView?) {
+        guard child.parent == nil, let parent = nearestViewController(from: view) else { return }
+        parent.addChild(child)
+        child.didMove(toParent: parent)
+    }
+
+    /// Detaches `child` from its parent. No-op when it was never attached.
+    static func detach(_ child: UIViewController) {
+        guard child.parent != nil else { return }
+        child.willMove(toParent: nil)
+        child.removeFromParent()
+    }
+}

package/ios/wrappers/inbox/RCTNotificationInboxBellNative.h

@@ -0,0 +1,12 @@
+// See RCTInlineMessageNative.h for why this RCTViewComponentView import is guarded by __cplusplus.
+#ifdef __cplusplus
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTNotificationInboxBellNative : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/wrappers/inbox/RCTNotificationInboxBellNative.mm

@@ -0,0 +1,98 @@
+#import "RCTNotificationInboxBellNative.h"
+#import "ReactNotificationInboxBellView.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 hosting the SwiftUI NotificationInboxBell.
+@interface RCTNotificationInboxBellNative () <RCTNotificationInboxBellNativeViewProtocol>
+@property(nonatomic, strong) id bridge;
+@end
+
+@implementation RCTNotificationInboxBellNative
+
+- (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 = NotificationInboxBellNativeShadowNode::defaultSharedProps();
+
+    // The Swift bridge is @available(iOS 16.0, *) because the bell opens the SDK's inbox sheet, which
+    // uses system detents. Below iOS 16 the class exists but must not be instantiated, so the view
+    // stays empty rather than crashing — every method below therefore tolerates a nil bridge.
+    if (@available(iOS 16.0, *)) {
+      Class bridgeClass = NSClassFromString(@"ReactNotificationInboxBellView");
+      if (bridgeClass) {
+        self.bridge = [[bridgeClass alloc] initWithContainerView:self];
+        [self assertBridgeAvailable:@"creating ReactNotificationInboxBellView bridge instance"];
+        [self.bridge setEventEmitter:self];
+      }
+    }
+  }
+  return self;
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (self.bridge == nil) {
+    return;
+  }
+  [self.bridge updateLayout:[NSValue valueWithCGRect:self.bounds]];
+}
+
+// Containment can only happen once the view is in a window: React Native creates component views
+// before mounting them, so at init there is no parent view controller to attach the host to.
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  if (self.bridge == nil) {
+    return;
+  }
+  if (self.window != nil) {
+    [self.bridge attachToParentViewController];
+  } else {
+    [self.bridge detachFromParentViewController];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  if (self.bridge == nil) {
+    return;
+  }
+  [self.bridge prepareForRecycle];
+}
+
+- (void)emitOnTapEvent:(NSDictionary *)event {
+  if (_eventEmitter) {
+    NotificationInboxBellNativeEventEmitter::OnTap result =
+        NotificationInboxBellNativeEventEmitter::OnTap{};
+    self.eventEmitter.onTap(result);
+  }
+}
+
+- (const NotificationInboxBellNativeEventEmitter &)eventEmitter {
+  return static_cast<const NotificationInboxBellNativeEventEmitter &>(*_eventEmitter);
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<NotificationInboxBellNativeComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> NotificationInboxBellNativeCls(void) {
+  return RCTNotificationInboxBellNative.class;
+}

package/ios/wrappers/inbox/RCTNotificationInboxViewNative.h

@@ -0,0 +1,12 @@
+// See RCTInlineMessageNative.h for why this RCTViewComponentView import is guarded by __cplusplus.
+#ifdef __cplusplus
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTNotificationInboxViewNative : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+#endif

package/ios/wrappers/inbox/RCTNotificationInboxViewNative.mm

@@ -0,0 +1,78 @@
+#import "RCTNotificationInboxViewNative.h"
+#import "ReactNotificationInboxView.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 hosting the SwiftUI NotificationInboxView (message list).
+/// This view emits no events; message actions flow through the existing global InboxEventListener.
+@interface RCTNotificationInboxViewNative () <RCTNotificationInboxViewNativeViewProtocol>
+@property(nonatomic, strong) id bridge;
+@end
+
+@implementation RCTNotificationInboxViewNative
+
+- (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 = NotificationInboxViewNativeShadowNode::defaultSharedProps();
+
+    Class bridgeClass = NSClassFromString(@"ReactNotificationInboxView");
+    if (bridgeClass) {
+      self.bridge = [[bridgeClass alloc] initWithContainerView:self];
+      [self assertBridgeAvailable:@"creating ReactNotificationInboxView bridge instance"];
+      [self.bridge setEventEmitter:self];
+    }
+  }
+  return self;
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self assertBridgeAvailable:@"during layoutSubviews"];
+  [self.bridge updateLayout:[NSValue valueWithCGRect:self.bounds]];
+}
+
+// Containment can only happen once the view is in a window: React Native creates component views
+// before mounting them, so at init there is no parent view controller to attach the host to. The list
+// presents nothing, but containment is what gives the hosted SwiftUI a correct trait/safe-area chain
+// and lifecycle callbacks.
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  [self assertBridgeAvailable:@"during didMoveToWindow"];
+  if (self.window != nil) {
+    [self.bridge attachToParentViewController];
+  } else {
+    [self.bridge detachFromParentViewController];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self assertBridgeAvailable:@"during prepareForRecycle"];
+  [self.bridge prepareForRecycle];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<NotificationInboxViewNativeComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> NotificationInboxViewNativeCls(void) {
+  return RCTNotificationInboxViewNative.class;
+}

package/ios/wrappers/inbox/ReactInboxEventListener.swift

@@ -0,0 +1,76 @@
+import ZixflowInternalCommon
+import ZixflowMessagingInApp
+
+/**
+ * React Native bridge for Zixflow Visual Notification Inbox events.
+ *
+ * Registered on the SDK (via `MessagingInApp.shared.setInboxEventListener`) only while a JS listener
+ * is registered. Because the New-Arch event emitter is one-way we cannot round-trip a bool back from
+ * JS, so `messageActionTaken` forwards the event fire-and-forget and RETURNS `true` — telling the SDK
+ * the host handled the action so the SDK suppresses its default navigation. The JS host owns action
+ * handling while a listener is registered. Observational callbacks forward fire-and-forget.
+ */
+public class ReactInboxEventListener: InboxEventListener {
+    // Shared instance for global access
+    public static let shared = ReactInboxEventListener()
+
+    private init() {}
+
+    // 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 inbox message event to React Native with a serialized message payload
+    private func emitInboxEvent(
+        eventType: String,
+        message: InboxMessage,
+        actionName: String? = nil,
+        actionValue: String? = nil
+    ) {
+        var data: [String: Any?] = [
+            ZixflowConstants.eventType: eventType,
+            ZixflowConstants.inboxMessage: message.toDictionary()
+        ]
+
+        if let actionName = actionName {
+            data[ZixflowConstants.actionName] = actionName
+        }
+        if let actionValue = actionValue {
+            data[ZixflowConstants.actionValue] = actionValue
+        }
+
+        eventEmitter?(data)
+    }
+
+    public func messageActionTaken(message: InboxMessage, actionName: String, actionValue: String) -> Bool {
+        emitInboxEvent(
+            eventType: ZixflowConstants.messageActionTaken,
+            message: message,
+            actionName: actionName,
+            actionValue: actionValue
+        )
+        // Host (React Native) owns action handling while a listener is registered.
+        return true
+    }
+
+    public func messageShown(message: InboxMessage) {
+        emitInboxEvent(eventType: ZixflowConstants.messageShown, message: message)
+    }
+
+    public func messageOpened(message: InboxMessage) {
+        emitInboxEvent(eventType: ZixflowConstants.messageOpened, message: message)
+    }
+
+    public func messageDismissed(message: InboxMessage) {
+        emitInboxEvent(eventType: ZixflowConstants.messageDismissed, message: message)
+    }
+}

package/ios/wrappers/inbox/ReactNotificationInboxBellView.h

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+
+@class UIView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Objective-C forward declaration for the Swift `ReactNotificationInboxBellView` class.
+ * See `ReactNotificationInboxOverlayView.h` for the rationale behind runtime resolution.
+ */
+@interface ReactNotificationInboxBellView : NSObject
+
+- (instancetype)initWithContainerView:(UIView *)containerView;
+- (void)setEventEmitter:(id)eventEmitter;
+- (void)updateLayout:(NSValue *)boundsValue;
+- (void)attachToParentViewController;
+- (void)detachFromParentViewController;
+- (void)prepareForRecycle;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/wrappers/inbox/ReactNotificationInboxBellView.swift

@@ -0,0 +1,109 @@
+import ZixflowMessagingInbox
+import Foundation
+import SwiftUI
+import UIKit
+
+/// React Native wrapper hosting the SwiftUI `NotificationInboxOverlay` inside a `UIHostingController`.
+///
+/// Despite the name, the hosted composition is the overlay rather than the bare `NotificationInboxBell`:
+/// only the overlay ties the bell to the SDK's own inbox sheet, and the wrapper deliberately does not
+/// reimplement panel presentation. Sized to the frame React Native assigns, that composition *is* a bell
+/// that opens the inbox — the component wrappers expose.
+///
+/// Remote branding still styles the bell (colors, icon). Branding's bell *position* has no effect here:
+/// alignment resolves inside this view's frame, so the host owns placement via `style`.
+///
+/// iOS 16+ because the panel is a sheet with system detents.
+@available(iOS 16.0, *)
+@objc(ReactNotificationInboxBellView)
+class ReactNotificationInboxBellView: NSObject {
+    private weak var eventEmitter: AnyObject?
+    private weak var containerView: UIView?
+    private let hostingController: UIHostingController<NotificationInboxOverlay>
+
+    @objc
+    init(containerView: UIView) {
+        self.containerView = containerView
+        self.hostingController = UIHostingController(rootView: NotificationInboxOverlay())
+        super.init()
+
+        let hostedView = hostingController.view!
+        hostedView.backgroundColor = .clear
+        hostedView.translatesAutoresizingMaskIntoConstraints = false
+        containerView.addSubview(hostedView)
+        NSLayoutConstraint.activate([
+            hostedView.topAnchor.constraint(equalTo: containerView.topAnchor),
+            hostedView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor),
+            hostedView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            hostedView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor)
+        ])
+
+        // Observational tap reporting. The SDK owns presentation, so this recognizer must not consume
+        // the touch: `cancelsTouchesInView = false` lets SwiftUI still receive it and open the sheet.
+        // It reports any tap inside this view's frame, which is the bell when the view is sized to it.
+        let tapObserver = UITapGestureRecognizer(target: self, action: #selector(handleObservedTap))
+        tapObserver.cancelsTouchesInView = false
+        tapObserver.delaysTouchesEnded = false
+        containerView.addGestureRecognizer(tapObserver)
+    }
+
+    @objc
+    func setEventEmitter(_ eventEmitter: AnyObject?) {
+        self.eventEmitter = eventEmitter
+    }
+
+    /// Adds the hosting controller to the view-controller hierarchy once the view is in a window.
+    ///
+    /// Without this the controller is orphaned, and the sheet it presents resolves its safe-area insets
+    /// against the wrong container — which showed up as a phantom top margin when dragging the sheet.
+    @objc
+    func attachToParentViewController() {
+        InboxHostContainment.attach(hostingController, hostedIn: containerView)
+    }
+
+    @objc
+    func detachFromParentViewController() {
+        InboxHostContainment.detach(hostingController)
+    }
+
+    @objc
+    func updateLayout(_ boundsValue: NSValue) {
+        hostingController.view.frame = boundsValue.cgRectValue
+        hostingController.view.setNeedsLayout()
+        hostingController.view.layoutIfNeeded()
+    }
+
+    @objc
+    func prepareForRecycle() {
+        // Deliberately does NOT remove the hosted view from its container.
+        //
+        // Fabric recycles the component view, and detaching the SwiftUI view here with nothing to
+        // re-attach it made a reused view come back blank. `ReactInlineMessageView` does not touch the
+        // hierarchy either. Containment is released here because a recycled view is leaving its parent.
+        detachFromParentViewController()
+    }
+
+    // MARK: - Event Emission
+
+    @objc
+    private func handleObservedTap() {
+        emitEvent("emitOnTapEvent:", payload: [:])
+    }
+
+    /// Mirrors `ReactInlineMessageView.emitEvent`: asserts rather than returning silently, so a
+    /// mis-wired emitter surfaces in debug instead of the tap simply never reaching JS.
+    private func emitEvent(_ selectorName: String, payload: [String: Any?]) {
+        guard let emitter = eventEmitter else {
+            assertionFailure("Event emitter is nil when trying to emit \(selectorName)")
+            return
+        }
+
+        let selector = Selector((selectorName))
+        guard emitter.responds(to: selector) else {
+            assertionFailure("Event emitter does not respond to selector: \(selectorName)")
+            return
+        }
+
+        _ = emitter.perform(selector, with: payload as NSDictionary)
+    }
+}

package/ios/wrappers/inbox/ReactNotificationInboxView.h

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+
+@class UIView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Objective-C forward declaration for the Swift `ReactNotificationInboxView` class.
+ * See `ReactNotificationInboxOverlayView.h` for the rationale behind runtime resolution.
+ */
+@interface ReactNotificationInboxView : NSObject
+
+- (instancetype)initWithContainerView:(UIView *)containerView;
+- (void)setEventEmitter:(id)eventEmitter;
+- (void)updateLayout:(NSValue *)boundsValue;
+- (void)attachToParentViewController;
+- (void)detachFromParentViewController;
+- (void)prepareForRecycle;
+
+@end
+
+NS_ASSUME_NONNULL_END