zixflow-reactnative 1.1.3 → 1.1.4

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

package/ios/wrappers/liveactivities/NativeLiveActivities.swift

@@ -0,0 +1,390 @@
+#if ZIXFLOW_LIVEACTIVITIES_ENABLED
+import ActivityKit
+import ZixflowDataPipelines
+import ZixflowInternalCommon
+import ZixflowLiveActivities
+import ZixflowLiveActivities_Attributes
+import ZixflowLiveActivities_Templates
+import Foundation
+import UIKit
+
+@objc(NativeZixflowLiveActivities)
+public class NativeLiveActivities: NSObject {
+    /// Reverse-DNS activity type identifiers for the SDK's built-in templates. These are the same
+    /// strings the backend sends as `notificationType` and that Android's `LiveNotificationType`
+    /// exposes, so JS, both native SDKs, and the wire format share one vocabulary.
+    enum TypeIdentifier {
+        static let segments = "com.zixflow.livenotifications.segments"
+        static let countdownTimer = "com.zixflow.livenotifications.countdowntimer"
+        /// Discriminator JavaScript sends for the custom template. Not a wire identifier — the
+        /// activity is reported under the app's own `liveNotifications.customType`.
+        static let custom = "custom"
+    }
+
+    /// Type-erased handles keyed by activity id. The native `start` returns a generic
+    /// `CIOLiveActivity<Attributes>` that can't cross the bridge, so we keep closures that capture
+    /// the concrete handle and rebuild its content-state from a JS map on update.
+    private struct ActivityBox {
+        let update: ([String: Any]) async throws -> Void
+        let end: ([String: Any]?) async throws -> Void
+    }
+
+    private static var activities: [String: ActivityBox] = [:]
+    private static let lock = NSLock()
+
+    /// Records an `update`/`end` aimed at an activity this process never started. Not surfaced to
+    /// JavaScript — see the call sites — but worth a log, because the same message covers both a
+    /// genuine caller mistake and the expected post-restart / push-started cases.
+    private static func logUnknownActivity(_ activityId: String, method: String) {
+        DIGraphShared.shared.logger.info(
+            "Live Activities: \(method) ignored — no activity with id \(activityId) was started by this app session. " +
+                "Activities started before an app restart, or started by a push, are not tracked in-process."
+        )
+    }
+
+    // MARK: - Module registration
+
+    /// Build the Live Activities module from the SDK config's `liveNotifications` key, mirroring
+    /// ``NativeLocation/module(from:)``. Registers the enabled built-in template attribute types so
+    /// `Zixflow.liveActivities.start` can request them, and so push-to-start tokens register for
+    /// them at SDK init.
+    ///
+    /// Unrecognized type identifiers are ignored: a newer native SDK may ship templates this
+    /// wrapper build doesn't know, and that must never break registration of the ones it does.
+    static func module(from config: [String: Any]) -> LiveActivitiesModule? {
+        guard let liveConfig = config["liveNotifications"] as? [String: Any] else { return nil }
+        guard #available(iOS 16.2, *) else { return nil }
+        let types = (liveConfig["types"] as? [String]) ?? []
+        var builder = LiveActivityConfigBuilder()
+        for type in types {
+            switch type {
+            case TypeIdentifier.segments:
+                builder = builder.register(CIOSegmentsAttributes.self)
+            case TypeIdentifier.countdownTimer:
+                builder = builder.register(CIOCountdownTimerAttributes.self)
+            default:
+                continue
+            }
+        }
+        // The custom template registers one SDK-owned Swift type under the app's own identifier.
+        // That indirection is what lets a JavaScript app have a custom activity at all: the SDK needs
+        // a metatype to register and to observe push-to-start for, and a metatype can't cross a bridge.
+        let trimmedCustomType = (liveConfig["customType"] as? String)?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        let customType = (trimmedCustomType?.isEmpty == false) ? trimmedCustomType : nil
+        if let customType {
+            builder = builder.register(CIOCustomAttributes.self, identifier: customType)
+        }
+        return LiveActivitiesModule(config: builder.build())
+    }
+
+    // MARK: - Bridge methods
+
+    @objc(start:resolve:reject:)
+    public func start(
+        _ payload: NSDictionary,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard #available(iOS 16.2, *) else {
+            return reject(Self.unavailableCode, Self.unavailableMessage, nil)
+        }
+        guard let map = payload as? [String: Any], let type = map["type"] as? String else {
+            return reject("live_activity_start_failed", "payload.type is required", nil)
+        }
+        do {
+            // A nil handle means the module isn't registered or this type wasn't enabled. The
+            // native SDK logs and returns nil rather than throwing, so surface it as a rejected
+            // promise — never a crash.
+            let id: String
+            switch type {
+            case TypeIdentifier.segments:
+                guard let handle = try Zixflow.liveActivities.start(
+                    CIOSegmentsAttributes(header: try Self.requireString(map, "header")),
+                    contentState: Self.segmentsState(from: map)
+                ) else {
+                    return reject(Self.notRegisteredCode, Self.notRegisteredMessage(type), nil)
+                }
+                Self.store(handle: handle, contentBuilder: Self.segmentsState)
+                id = handle.id
+            case TypeIdentifier.countdownTimer:
+                guard let handle = try Zixflow.liveActivities.start(
+                    CIOCountdownTimerAttributes(header: try Self.requireString(map, "header")),
+                    contentState: Self.countdownState(from: map)
+                ) else {
+                    return reject(Self.notRegisteredCode, Self.notRegisteredMessage(type), nil)
+                }
+                Self.store(handle: handle, contentBuilder: Self.countdownState)
+                id = handle.id
+            case TypeIdentifier.custom:
+                // No pre-check on the stored identifier: the SDK config can also be built by generated
+                // native code that never calls `module(from:)` — the Expo config plugin does exactly
+                // that — so a nil stored value doesn't mean the type is unregistered. Attempt the start
+                // and let the SDK answer; a nil handle means it genuinely isn't registered.
+                guard let handle = try Zixflow.liveActivities.start(
+                    CIOCustomAttributes(),
+                    contentState: Self.customState(from: map)
+                ) else {
+                    return reject(Self.notRegisteredCode, Self.customNotRegisteredMessage, nil)
+                }
+                Self.store(handle: handle, contentBuilder: Self.customState)
+                id = handle.id
+            default:
+                // A newer native SDK may know this type even though this wrapper build doesn't.
+                // Fail softly so an unrecognized template can never crash the host app.
+                return reject(Self.unsupportedTypeCode, "Unsupported Live Activity template: \(type)", nil)
+            }
+            resolve(id)
+        } catch {
+            reject("live_activity_start_failed", error.localizedDescription, error)
+        }
+    }
+
+    @objc(update:payload:resolve:reject:)
+    public func update(
+        _ activityId: String,
+        payload: NSDictionary,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Self.lock.lock()
+        let box = Self.activities[activityId]
+        Self.lock.unlock()
+        // An unknown id means the update did not happen, so it must not report success. Unlike `end`
+        // — where re-ending an already-ended activity is a legitimate no-op — there is nothing
+        // idempotent about an update that never applied. Android *does* perform it (it routes the id
+        // straight to the native SDK), so resolving here would make the same call report success on
+        // both platforms while only one of them did anything.
+        guard let box else {
+            Self.logUnknownActivity(activityId, method: "update")
+            return reject(
+                "live_activity_update_failed",
+                "No live activity found for id \(activityId). On iOS only activities started in this " +
+                    "app session can be updated.",
+                nil
+            )
+        }
+        guard let map = payload as? [String: Any] else {
+            return reject("live_activity_update_failed", "payload is required", nil)
+        }
+        Task {
+            do {
+                try await box.update(map)
+                resolve(nil)
+            } catch {
+                reject("live_activity_update_failed", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(end:payload:resolve:reject:)
+    public func end(
+        _ activityId: String,
+        payload: NSDictionary?,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Self.lock.lock()
+        let box = Self.activities[activityId]
+        Self.lock.unlock()
+        // Unknown/already-ended id is treated as success (idempotent end). See `update` for why an
+        // unknown id is not an error.
+        guard let box else {
+            Self.logUnknownActivity(activityId, method: "end")
+            return resolve(nil)
+        }
+        let map = payload as? [String: Any]
+        Task {
+            do {
+                try await box.end(map)
+                // Dropped only once the end succeeded. Removing up front would lose the handle on a
+                // throw, and the retry would then take the unknown-id path above and report success
+                // for an activity still on screen.
+                Self.forget(activityId)
+                resolve(nil)
+            } catch {
+                reject("live_activity_end_failed", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(handleWidgetUrl:resolve:reject:)
+    public func handleWidgetUrl(
+        _ urlString: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject _: @escaping RCTPromiseRejectBlock
+    ) {
+        guard let url = URL(string: urlString) else {
+            resolve(urlString)
+            return
+        }
+        guard let destination = Self.handleWidgetUrl(url) else {
+            // React Native maps NSNull to JavaScript null. Resolving Swift nil produces undefined,
+            // which would violate the public Promise<string | null> contract.
+            resolve(NSNull())
+            return
+        }
+        resolve(destination.absoluteString)
+    }
+
+    /// Report an `opened` metric for a tapped Live Activity and return the deep link to route to.
+    ///
+    /// - Returns: the customer's redirect URL for a Zixflow widget URL (`nil` when it carries
+    ///   none), or `url` unchanged when it isn't a Zixflow URL — so existing routing still
+    ///   handles non-CIO links.
+    @discardableResult
+    public static func handleWidgetUrl(_ url: URL) -> URL? {
+        Zixflow.liveActivities.handleWidgetUrl(url)
+    }
+
+    /// Report an `opened` metric for a tapped Live Activity and route its destination through the
+    /// configured Zixflow router. Ordinary URLs continue through React Native Linking.
+    @objc(handleAndRouteWidgetUrl:)
+    public static func handleAndRouteWidgetUrl(_ url: URL) {
+        guard let routableUrl = handleWidgetUrl(url) else { return }
+        if routableUrl == url {
+            ZixflowReactNativeDeepLinkRouter.route(routableUrl)
+        } else {
+            ZixflowReactNativeDeepLinkRouter.accept(routableUrl)
+        }
+    }
+
+    /// Build React Native launch options from a scene connection, reporting a cold Live Activity
+    /// tap and routing its destination through the installed Zixflow scene router. Without the
+    /// acknowledged-handler opt-in, the destination remains in React Native's launch options. This
+    /// mirrors the `RCTConvertConnectionOptionsToLaunchOptions` conversion verified in React Native
+    /// 0.88.0-nightly-20260823-0c7f63a4e. Before `Zixflow.initialize`, the native Live Activities
+    /// stub parses the redirect and buffers the opened metric for the module to flush at initialization.
+    @objc(reactNativeLaunchOptionsFromConnectionOptions:)
+    public static func reactNativeLaunchOptions(
+        from connectionOptions: UIScene.ConnectionOptions
+    ) -> [UIApplication.LaunchOptionsKey: Any] {
+        var launchOptions: [UIApplication.LaunchOptionsKey: Any] = [:]
+
+        if let url = connectionOptions.urlContexts.first?.url,
+           let routableUrl = handleWidgetUrl(url)
+        {
+            if ZixflowReactNativeDeepLinkRouter.requiresAcknowledgedHandler,
+               routableUrl != url
+            {
+                ZixflowReactNativeDeepLinkRouter.accept(routableUrl)
+            } else {
+                launchOptions[.url] = routableUrl
+            }
+        }
+
+        if let userActivity = connectionOptions.userActivities.first {
+            launchOptions[.userActivityDictionary] = [
+                UIApplication.LaunchOptionsKey.userActivityType.rawValue: userActivity.activityType,
+                "UIApplicationLaunchOptionsUserActivityKey": userActivity,
+            ]
+        }
+
+        return launchOptions
+    }
+
+    // MARK: - Helpers
+
+    @available(iOS 16.2, *)
+    private static func store<A: ActivityAttributes>(
+        handle: CIOLiveActivity<A>,
+        contentBuilder: @escaping ([String: Any]) throws -> A.ContentState
+    ) {
+        let box = ActivityBox(
+            // ActivityKit keeps the last content-state on screen when `end` is given none, so a
+            // final payload is what lets the activity show a terminal state rather than freezing
+            // mid-progress.
+            update: { map in await handle.update(try contentBuilder(map)) },
+            end: { map in await handle.end(try map.map(contentBuilder)) }
+        )
+        lock.lock()
+        activities[handle.id] = box
+        lock.unlock()
+    }
+
+    private static func forget(_ activityId: String) {
+        lock.lock()
+        activities.removeValue(forKey: activityId)
+        lock.unlock()
+    }
+
+    /// Thrown for a missing required field so the caller sees a rejected promise naming it, rather
+    /// than an activity rendering with a blank line. Matches Android, whose `requireString` /
+    /// `requireDouble` already reject — an untyped JavaScript caller should not get a silent
+    /// half-rendered card on one platform and an error on the other.
+    private struct MissingFieldError: LocalizedError {
+        let field: String
+        var errorDescription: String? { "\(field) is required" }
+    }
+
+    private static func requireString(_ map: [String: Any], _ key: String) throws -> String {
+        guard let value = map[key] as? String else { throw MissingFieldError(field: key) }
+        return value
+    }
+
+    private static func requireInt(_ map: [String: Any], _ key: String) throws -> Int {
+        guard let value = map[key] as? NSNumber else { throw MissingFieldError(field: key) }
+        return value.intValue
+    }
+
+    @available(iOS 16.2, *)
+    private static func segmentsState(from map: [String: Any]) throws -> CIOSegmentsAttributes.ContentState {
+        CIOSegmentsAttributes.ContentState(
+            status: try requireString(map, "status"),
+            substatus: map["substatus"] as? String,
+            segmentsTotal: try requireInt(map, "segmentsTotal"),
+            segmentsComplete: try requireInt(map, "segmentsComplete"),
+            trailingText: map["trailingText"] as? String
+        )
+    }
+
+    @available(iOS 16.2, *)
+    private static func countdownState(from map: [String: Any]) throws -> CIOCountdownTimerAttributes.ContentState {
+        var endTime: EpochSecondsDate?
+        if let seconds = map["endTime"] as? NSNumber {
+            endTime = EpochSecondsDate(Date(timeIntervalSince1970: seconds.doubleValue))
+        }
+        return CIOCountdownTimerAttributes.ContentState(
+            title: try requireString(map, "title"),
+            statusMessage: map["statusMessage"] as? String,
+            endTime: endTime
+        )
+    }
+
+    /// Builds the custom template's content-state from the JS payload's `data` map.
+    ///
+    /// Values are coerced to strings rather than rejected: JavaScript numbers and booleans arrive as
+    /// `NSNumber`, and refusing them would make `{ eta: 5 }` fail for no reason a caller can see.
+    /// Anything without a sensible text form is dropped instead of stringifying as gibberish.
+    @available(iOS 16.2, *)
+    private static func customState(from map: [String: Any]) throws -> CIOCustomAttributes.ContentState {
+        let raw = map["data"] as? [String: Any] ?? [:]
+        var data: [String: String] = [:]
+        for (key, value) in raw {
+            switch value {
+            case let string as String: data[key] = string
+            case let number as NSNumber: data[key] = number.stringValue
+            default: continue
+            }
+        }
+        return CIOCustomAttributes.ContentState(data: data)
+    }
+
+    private static let unavailableCode = "live_activity_module_unavailable"
+    private static let unavailableMessage =
+        "Live Activities require iOS 16.2 or later."
+
+    private static let customNotRegisteredMessage =
+        "No custom Live Activity type is registered. Set `liveNotifications.customType` in your " +
+        "Zixflow SDK config to your own reverse-DNS identifier, and render CIOCustomAttributes " +
+        "in your Widget Extension."
+
+    private static let notRegisteredCode = "live_activity_type_not_registered"
+    private static func notRegisteredMessage(_ type: String) -> String {
+        "Live Activity type '\(type)' is not registered. Add it to `liveNotifications.types` in your " +
+            "Zixflow SDK config, and make sure your widget extension renders it."
+    }
+
+    private static let unsupportedTypeCode = "live_activity_type_unsupported"
+}
+#endif

package/ios/wrappers/location/NativeLocation.swift

@@ -6,11 +6,13 @@ import CoreLocation
 @objc(NativeZixflowLocation)
 public class NativeLocation: NSObject {
 
-    /// Parses the root config and returns a `LocationModule` if location config is present.
-    /// Keeps config parsing within the location module.
-    static func module(from config: [String: Any]) -> LocationModule? {
-        guard let locationConfig = config["location"] as? [String: Any] else { return nil }
-        let trackingModeValue = locationConfig["trackingMode"] as? String
+    /// Parses the root config and returns a `LocationModule` when location config is present
+    /// or when geofence is enabled (geofence depends on the location module). Keeps config
+    /// parsing within the location module. Defaults to `manual` tracking when no config is given.
+    static func module(from config: [String: Any], geofenceEnabled: Bool = false) -> LocationModule? {
+        let locationConfig = config["location"] as? [String: Any]
+        guard locationConfig != nil || geofenceEnabled else { return nil }
+        let trackingModeValue = locationConfig?["trackingMode"] as? String
         let mode: LocationTrackingMode
         switch trackingModeValue?.uppercased() {
         case "OFF":

package/ios/wrappers/utils/ZixflowConstants.swift

@@ -11,6 +11,10 @@ enum ZixflowConstants {
     static let errorWithMessage = "errorWithMessage"
     static let messageActionTaken = "messageActionTaken"
 
+    // Notification Inbox event listener
+    static let messageOpened = "messageOpened"
+    static let inboxMessage = "message"
+
     // Push Messaging
     static let zixflowDeliveryId = "ZIXFLOW-Delivery-ID"
     static let zixflowDeliveryToken = "ZIXFLOW-Delivery-Token"

package/ios/wrappers/zixflow_reactnative.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+// Public module header required when CocoaPods builds the wrapper as a static library. Swift's
+// generated compatibility header imports this path before exposing the wrapper's Swift types.

package/lib/commonjs/components/NotificationInboxBellView.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _NotificationInboxBellNativeComponent = _interopRequireDefault(require("../specs/components/NotificationInboxBellNativeComponent"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Props for the {@link NotificationInboxBellView} component.
+ */
+/** @public */
+
+/**
+ * The Visual Notification Inbox bell (with unread badge). Tapping it opens the
+ * SDK's own inbox panel — the host presents nothing.
+ *
+ * Place it wherever the app's layout calls for it. Remote branding still styles
+ * the bell itself (colors, icon), but branding's *position* is not applied: the
+ * host owns placement via `style`. The bell renders nothing when the inbox has
+ * nothing to show, so give it a fixed size for predictable layout — at least 88
+ * points/dp square, since the native composition insets the 56pt bell by 16 on
+ * each side and a smaller box squeezes the circle onto the glyph.
+ *
+ * @example
+ * ```tsx
+ * <NotificationInboxBellView
+ *   style={{ width: 88, height: 88 }}
+ *   onTap={() => analytics.track('inbox_bell_tapped')}
+ * />
+ * ```
+ */
+/** @public */
+const NotificationInboxBellView = ({
+  onTap,
+  ...props
+}) => {
+  const handleTap = () => {
+    onTap?.();
+  };
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_NotificationInboxBellNativeComponent.default, {
+    ...props,
+    onTap: handleTap
+  });
+};
+var _default = exports.default = NotificationInboxBellView;
+//# sourceMappingURL=NotificationInboxBellView.js.map

package/lib/commonjs/components/NotificationInboxBellView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_NotificationInboxBellNativeComponent","_jsxRuntime","e","__esModule","default","NotificationInboxBellView","onTap","props","handleTap","jsx","_default","exports"],"sourceRoot":"../../../src","sources":["components/NotificationInboxBellView.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,qCAAA,GAAAF,sBAAA,CAAAC,OAAA;AAEkE,IAAAE,WAAA,GAAAF,OAAA;AAAA,SAAAD,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAElE;AACA;AACA;AACA;;AAeA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,yBAAmE,GAAGA,CAAC;EAC3EC,KAAK;EACL,GAAGC;AACL,CAAC,KAAK;EACJ,MAAMC,SAAS,GAAGA,CAAA,KAAM;IACtBF,KAAK,GAAG,CAAC;EACX,CAAC;EAED,oBAAO,IAAAL,WAAA,CAAAQ,GAAA,EAACT,qCAAA,CAAAI,OAAoC;IAAA,GAAKG,KAAK;IAAED,KAAK,EAAEE;EAAU,CAAE,CAAC;AAC9E,CAAC;AAAC,IAAAE,QAAA,GAAAC,OAAA,CAAAP,OAAA,GAEaC,yBAAyB","ignoreList":[]}

package/lib/commonjs/components/NotificationInboxView.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _NotificationInboxViewNativeComponent = _interopRequireDefault(require("../specs/components/NotificationInboxViewNativeComponent"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Props for the {@link NotificationInboxView} component.
+ */
+/** @public */
+
+/**
+ * The Visual Notification Inbox message list — the Jist-rendered messages —
+ * embeddable directly in your own screen. It fills the area you give it via
+ * `style` and brings no surrounding chrome (no bell, no scrim).
+ *
+ * Message actions are handled by the existing global InboxEventListener, so this
+ * component takes no per-message action callback.
+ *
+ * @example
+ * ```tsx
+ * <NotificationInboxView style={{ flex: 1 }} />
+ * ```
+ */
+/** @public */
+const NotificationInboxView = props => {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_NotificationInboxViewNativeComponent.default, {
+    ...props
+  });
+};
+var _default = exports.default = NotificationInboxView;
+//# sourceMappingURL=NotificationInboxView.js.map