zixflow-reactnative 1.1.2 → 1.1.4

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

package/ios/wrappers/inbox/ReactNotificationInboxView.swift

@@ -0,0 +1,69 @@
+import ZixflowMessagingInbox
+import Foundation
+import SwiftUI
+import UIKit
+
+/// React Native wrapper hosting the SwiftUI `NotificationInboxView` (the Jist-rendered message
+/// list) inside a `UIHostingController`. No events; sizing is driven by the JS `style` prop.
+/// Message actions are handled by the existing global InboxEventListener.
+/// No `@available` annotation, matching `ReactInlineMessageView`: the native list view is iOS 13+,
+/// so the pod's own floor (`min_ios_version_supported`) governs.
+@objc(ReactNotificationInboxView)
+class ReactNotificationInboxView: NSObject {
+    private weak var containerView: UIView?
+    private let hostingController: UIHostingController<NotificationInboxView>
+
+    @objc
+    init(containerView: UIView) {
+        self.containerView = containerView
+        self.hostingController = UIHostingController(rootView: NotificationInboxView())
+        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)
+        ])
+    }
+
+    // Accepts the emitter for API symmetry with the other inbox views; this view emits no events.
+    @objc
+    func setEventEmitter(_ eventEmitter: AnyObject?) {}
+
+    /// Adds the hosting controller to the view-controller hierarchy once the view is in a window, so the
+    /// hosted SwiftUI gets a correct trait/safe-area chain and lifecycle callbacks instead of being
+    /// driven by an orphaned controller.
+    @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() {
+        detachFromParentViewController()
+        // Deliberately does NOT remove the hosted view from its container.
+        //
+        // Fabric recycles the component view, and the previous version detached the SwiftUI view here
+        // with nothing to re-attach it, so a reused view came back blank. `ReactInlineMessageView`
+        // does not touch the hierarchy either — it detaches observers (`onViewDetached`) and
+        // re-attaches in `setupForReuse`. These hosts have no props and no observers to reset, so
+        // there is nothing to undo: the hosted view stays mounted and is reused as-is.
+    }
+}

package/ios/wrappers/liveactivities/NativeLiveActivities.mm

@@ -0,0 +1,83 @@
+#import <React/RCTBridgeModule.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeLiveActivities : NSObject <NativeZixflowLiveActivitiesSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeZixflowLiveActivitiesSpec> swiftBridge;
+@end
+
+@implementation RCTNativeLiveActivities
+
+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::NativeZixflowLiveActivitiesSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Runtime class lookup - the Swift class only exists when the liveactivities subspec is installed.
+    Class swiftClass = NSClassFromString(@"NativeZixflowLiveActivities");
+    if (swiftClass) {
+      _swiftBridge = [[swiftClass alloc] init];
+    }
+  }
+  return self;
+}
+
+// Module initialization can happen on background thread
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)start:(NSDictionary *)payload
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject {
+  if (!_swiftBridge) {
+    reject(@"live_activity_module_unavailable", @"Live Activities are unavailable.", nil);
+    return;
+  }
+  [_swiftBridge start:payload resolve:resolve reject:reject];
+}
+
+- (void)update:(NSString *)activityId
+       payload:(NSDictionary *)payload
+       resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+  if (!_swiftBridge) {
+    reject(@"live_activity_module_unavailable", @"Live Activities are unavailable.", nil);
+    return;
+  }
+  [_swiftBridge update:activityId payload:payload resolve:resolve reject:reject];
+}
+
+- (void)end:(NSString *)activityId
+    payload:(NSDictionary *)payload
+    resolve:(RCTPromiseResolveBlock)resolve
+     reject:(RCTPromiseRejectBlock)reject {
+  if (!_swiftBridge) {
+    reject(@"live_activity_module_unavailable", @"Live Activities are unavailable.", nil);
+    return;
+  }
+  [_swiftBridge end:activityId payload:payload resolve:resolve reject:reject];
+}
+
+- (void)handleWidgetUrl:(NSString *)url
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  if (!_swiftBridge) {
+    resolve(url);
+    return;
+  }
+  [_swiftBridge handleWidgetUrl:url resolve:resolve reject:reject];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeZixflowLiveActivitiesCls(void) {
+  return RCTNativeLiveActivities.class;
+}
+
+@end