zixflow-reactnative 1.1.2 → 1.1.4

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/ZixflowConfigUtils.swift

@@ -3,14 +3,12 @@ import ZixflowInternalCommon
 import ZixflowMessagingInApp
 
 enum SDKConfigBuilderError: Error {
-    case missingCdpApiKey
+    case missingApiKey
 }
 
 extension SDKConfigBuilder {
     private enum Config: String {
-        case migrationSiteId
-        case cdpApiKey
-        case region
+        case apiKey
         case logLevel
         case apiHost
         case cdnHost
@@ -23,13 +21,11 @@ extension SDKConfigBuilder {
 
     @available(iOSApplicationExtension, unavailable)
     static func create(from config: [String: Any?]) throws -> SDKConfigBuilder {
-        guard let cdpApiKey = config[Config.cdpApiKey.rawValue] as? String else {
-            throw SDKConfigBuilderError.missingCdpApiKey
+        guard let apiKey = config[Config.apiKey.rawValue] as? String else {
+            throw SDKConfigBuilderError.missingApiKey
         }
 
-        let builder = SDKConfigBuilder(cdpApiKey: cdpApiKey)
-        Config.migrationSiteId.ifNotNil(in: config, thenPassItTo: builder.migrationSiteId)
-        Config.region.ifNotNil(in: config, thenPassItTo: builder.region, transformingBy: Region.getRegion)
+        let builder = SDKConfigBuilder(apiKey: apiKey)
         Config.logLevel.ifNotNil(in: config, thenPassItTo: builder.logLevel, transformingBy: ZixflowLogLevel.getLogLevel)
         Config.flushAt.ifNotNil(in: config, thenPassItTo: builder.flushAt) { (value: Double) in Int(value) }
         Config.flushInterval.ifNotNil(in: config, thenPassItTo: builder.flushInterval)

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_NotificationInboxViewNativeComponent","_jsxRuntime","e","__esModule","default","NotificationInboxView","props","jsx","_default","exports"],"sourceRoot":"../../../src","sources":["components/NotificationInboxView.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;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,qBAA2D,GAAIC,KAAK,IAAK;EAC7E,oBAAO,IAAAL,WAAA,CAAAM,GAAA,EAACP,qCAAA,CAAAI,OAAoC;IAAA,GAAKE;EAAK,CAAG,CAAC;AAC5D,CAAC;AAAC,IAAAE,QAAA,GAAAC,OAAA,CAAAL,OAAA,GAEaC,qBAAqB","ignoreList":[]}

package/lib/commonjs/components/index.js

@@ -9,6 +9,20 @@ Object.defineProperty(exports, "InlineInAppMessageView", {
     return _InlineInAppMessageView.default;
   }
 });
+Object.defineProperty(exports, "NotificationInboxBellView", {
+  enumerable: true,
+  get: function () {
+    return _NotificationInboxBellView.default;
+  }
+});
+Object.defineProperty(exports, "NotificationInboxView", {
+  enumerable: true,
+  get: function () {
+    return _NotificationInboxView.default;
+  }
+});
 var _InlineInAppMessageView = _interopRequireDefault(require("./InlineInAppMessageView.js"));
+var _NotificationInboxBellView = _interopRequireDefault(require("./NotificationInboxBellView.js"));
+var _NotificationInboxView = _interopRequireDefault(require("./NotificationInboxView.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["_InlineInAppMessageView","_interopRequireDefault","require","e","__esModule","default"],"sourceRoot":"../../../src","sources":["components/index.ts"],"mappings":";;;;;;;;;;;AAEA,IAAAA,uBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA6E,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}
+{"version":3,"names":["_InlineInAppMessageView","_interopRequireDefault","require","_NotificationInboxBellView","_NotificationInboxView","e","__esModule","default"],"sourceRoot":"../../../src","sources":["components/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAAA,uBAAA,GAAAC,sBAAA,CAAAC,OAAA;AAIA,IAAAC,0BAAA,GAAAF,sBAAA,CAAAC,OAAA;AAEA,IAAAE,sBAAA,GAAAH,sBAAA,CAAAC,OAAA;AAA2E,SAAAD,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}