zixflow-reactnative 1.0.0

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

@@ -0,0 +1,124 @@
+import CioMessagingInApp
+import Foundation
+import UIKit
+
+/// React Native wrapper for inline message display with content view lifecycle management.
+///
+/// This Swift class provides the actual functionality while allowing Objective-C/C++ files to
+/// import only the header for compile-time safety across different linking configurations.
+/// Methods are called dynamically from Objective-C using runtime resolution.
+@objc(ReactInlineMessageView)
+class ReactInlineMessageView: NSObject {
+    private weak var eventEmitter: AnyObject?
+    private let contentView: InlineMessageBridgeView = .init()
+
+    @objc
+    init(containerView: UIView) {
+        super.init()
+        contentView.attachToParent(parent: containerView, delegate: self)
+    }
+
+    @objc
+    func setEventEmitter(_ eventEmitter: AnyObject?) {
+        self.eventEmitter = eventEmitter
+    }
+
+    @objc
+    func setElementId(_ elementId: String) {
+        // Set element ID on the prepared content view
+        contentView.elementId = elementId
+    }
+
+    @objc
+    func setupForReuse() {
+        contentView.onViewAttached()
+    }
+
+    @objc
+    func prepareForRecycle() {
+        // Remove content view for reuse, cleaning up observers and releasing resources
+        contentView.onViewDetached()
+    }
+
+    @objc
+    func updateLayout(_ boundsValue: NSValue) {
+        let bounds = boundsValue.cgRectValue
+        contentView.frame = bounds
+        contentView.setNeedsLayout()
+        contentView.layoutIfNeeded()
+    }
+
+    // MARK: - Event Emission Helper
+
+    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)
+    }
+
+    private func sendOnSizeChangeEvent(width: Double = 0, height: Double) {
+        let duration = 200.0
+        var payload: [String: Any] = [
+            "height": height,
+            "duration": duration
+        ]
+
+        // Only include positive width values as rendering requires valid width to calculate layout size
+        if width > 0 {
+            payload["width"] = width
+        }
+
+        emitEvent("emitOnSizeChangeEvent:", payload: payload)
+    }
+
+    private func sendOnStateChangeEvent(state: InlineInAppMessageStateEvent) {
+        let payload: [String: Any] = [
+            "state": state.stringValue
+        ]
+
+        emitEvent("emitOnStateChangeEvent:", payload: payload)
+    }
+}
+
+extension ReactInlineMessageView: InlineMessageBridgeViewDelegate {
+    func onActionClick(message: InAppMessage, actionValue: String, actionName: String) -> Bool {
+        let payload: [String: Any?] = [
+            "message": [
+                "messageId": message.messageId,
+                "deliveryId": message.deliveryId,
+                "elementId": message.elementId
+            ],
+            "actionValue": actionValue,
+            "actionName": actionName
+        ]
+
+        emitEvent("emitOnActionClickEvent:", payload: payload)
+        return true
+    }
+
+    func onMessageSizeChanged(width: CGFloat, height: CGFloat) {
+        sendOnSizeChangeEvent(width: width, height: height)
+    }
+
+    func onNoMessageToDisplay() {
+        sendOnStateChangeEvent(state: .noMessageToDisplay)
+    }
+
+    func onStartLoading(onComplete: @escaping () -> Void) {
+        sendOnStateChangeEvent(state: .loadingStarted)
+        onComplete()
+    }
+
+    func onFinishLoading() {
+        sendOnStateChangeEvent(state: .loadingFinished)
+    }
+}

package/ios/wrappers/location/NativeLocation.mm

@@ -0,0 +1,52 @@
+#import <React/RCTBridgeModule.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeCustomerIOLocation : NSObject <NativeCustomerIOLocationSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeCustomerIOLocationSpec> swiftBridge;
+@end
+
+@implementation RCTNativeCustomerIOLocation
+
+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::NativeCustomerIOLocationSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Use runtime class lookup - NativeLocation class only exists when CioLocation subspec is installed
+    Class swiftClass = NSClassFromString(@"NativeCustomerIOLocation");
+    if (swiftClass) {
+      _swiftBridge = [[swiftClass alloc] init];
+    }
+  }
+  return self;
+}
+
+// Module initialization can happen on background thread
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)setLastKnownLocation:(double)latitude
+                    longitude:(double)longitude {
+  if (!_swiftBridge) return;
+  [_swiftBridge setLastKnownLocation:latitude longitude:longitude];
+}
+
+- (void)requestLocationUpdate {
+  if (!_swiftBridge) return;
+  [_swiftBridge requestLocationUpdate];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeCustomerIOLocationCls(void) {
+  return RCTNativeCustomerIOLocation.class;
+}
+
+@end

package/ios/wrappers/location/NativeLocation.swift

@@ -0,0 +1,37 @@
+#if CIO_LOCATION_ENABLED
+import CioDataPipelines
+import CioLocation
+import CoreLocation
+
+@objc(NativeCustomerIOLocation)
+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
+        let mode: LocationTrackingMode
+        switch trackingModeValue?.uppercased() {
+        case "OFF":
+            mode = .off
+        case "ON_APP_START":
+            mode = .onAppStart
+        default:
+            mode = .manual
+        }
+        return LocationModule(config: LocationConfig(mode: mode))
+    }
+
+    @objc
+    func setLastKnownLocation(_ latitude: Double, longitude: Double) {
+        let location = CLLocation(latitude: latitude, longitude: longitude)
+        CustomerIO.location.setLastKnownLocation(location)
+    }
+
+    @objc
+    func requestLocationUpdate() {
+        CustomerIO.location.requestLocationUpdate()
+    }
+}
+#endif

package/ios/wrappers/logging/NativeCustomerIOLogging.mm

@@ -0,0 +1,81 @@
+#import "../utils/RCTCustomerIOUtils.h"
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTInitializing.h>
+#import <React/RCTInvalidating.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Protocol that extends the spec with event emitter methods
+@protocol NativeCustomerIOLoggingBridge <NativeCustomerIOLoggingSpec, RCTInitializing, RCTInvalidating>
+- (void)setEventEmitter:(id)emitter;
+@end
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeCustomerIOLogging
+    : NativeCustomerIOLoggingSpecBase <NativeCustomerIOLoggingSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeCustomerIOLoggingBridge> swiftBridge;
+@end
+
+@implementation RCTNativeCustomerIOLogging
+
+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::NativeCustomerIOLoggingSpecJSI>(params);
+}
+
+// Validates Swift bridge is available before method calls
+- (void)assertBridgeAvailable:(NSString *)context {
+  RCT_ASSERT_BRIDGE_AVAILABLE(self.swiftBridge, context);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Use runtime class lookup to avoid import issues and circular dependencies
+    Class swiftClass = NSClassFromString(@"NativeCustomerIOLogging");
+    RCT_ASSERT_NOT_NIL(swiftClass, @"NativeCustomerIOLogging Swift class", @"during runtime lookup");
+    _swiftBridge = [[swiftClass alloc] init];
+    [self assertBridgeAvailable:@"creating NativeCustomerIOLogging Swift instance"];
+
+    // Set event emitter reference for new architecture
+    [_swiftBridge setEventEmitter:self];
+  }
+  return self;
+}
+
+// Background initialization is fine since logs are ignored until listeners are attached
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)initialize {
+  [self assertBridgeAvailable:@"during initialize"];
+  [_swiftBridge initialize];
+}
+
+- (void)invalidate {
+  [self assertBridgeAvailable:@"during invalidate"];
+  [_swiftBridge invalidate];
+}
+
+- (void)addListener:(nonnull NSString *)eventName {
+  RCT_LEGACY_ARCH_WARNING(addListener);
+}
+
+- (void)removeListeners:(double)count {
+  RCT_LEGACY_ARCH_WARNING(removeListeners);
+}
+
+- (void)emitOnCioLogEvent:(NSDictionary *)value {
+  [super emitOnCioLogEvent:value];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeCustomerIOLoggingCls(void) {
+  return RCTNativeCustomerIOLogging.class;
+}
+
+@end

package/ios/wrappers/logging/NativeCustomerIOLogging.swift

@@ -0,0 +1,62 @@
+import CioInternalCommon
+import Foundation
+import React
+
+// Logging module for new React Native architecture (TurboModule)
+@objc(NativeCustomerIOLogging)
+public class NativeCustomerIOLogging: NSObject {
+    // Reference to the ObjC event emitter for new architecture (TurboModule)
+    private weak var objcEventEmitter: AnyObject?
+    private lazy var logEventCallback: (_ body: [String: Any]) -> Void = { [weak self] body in
+        self?.sendEvent(body: body)
+    }
+
+    // Set ObjC event emitter reference for new architecture
+    @objc
+    public func setEventEmitter(_ emitter: AnyObject) {
+        objcEventEmitter = emitter
+    }
+
+    // Initialize log dispatcher - called by React Native
+    @objc
+    public func initialize() {
+        // Initialize log dispatcher when module is ready
+        DIGraphShared.shared.logger.setLogDispatcher { [weak self] level, message in
+            guard let self else { return }
+
+            let body = [
+                "logLevel": level.rawValue,
+                "message": message
+            ]
+            logEventCallback(body)
+        }
+    }
+
+    // Clear log dispatcher to prevent leaks - called by React Native
+    @objc
+    public func invalidate() {
+        // Clear log dispatcher to prevent leaks
+        clearLogEventListener()
+    }
+
+    // Clears the log dispatcher to prevent leaks when module is deallocated or invalidated
+    private func clearLogEventListener() {
+        DIGraphShared.shared.logger.setLogDispatcher(nil)
+    }
+
+    // Send log event to React Native layer using ObjC event emitter
+    private func sendEvent(body: [String: Any]) {
+        guard let emitter = objcEventEmitter else {
+            assertionFailure("NativeCustomerIOLogging: ObjC event emitter is nil, cannot send log event")
+            return
+        }
+
+        // New architecture: use injected ObjC event emitter from TurboModule
+        let selector = Selector(("emitOnCioLogEvent:"))
+        guard emitter.responds(to: selector) else {
+            assertionFailure("ObjC event emitter does not respond to selector: emitOnCioLogEvent:")
+            return
+        }
+        _ = emitter.perform(selector, with: body as NSDictionary)
+    }
+}

package/ios/wrappers/push/NativeMessagingPush.mm

@@ -0,0 +1,87 @@
+#import "../utils/RCTCustomerIOUtils.h"
+#import <React/RCTBridgeModule.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeMessagingPush : NSObject <NativeCustomerIOMessagingPushSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeCustomerIOMessagingPushSpec> swiftBridge;
+@end
+
+@implementation RCTNativeMessagingPush
+
+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::NativeCustomerIOMessagingPushSpecJSI>(params);
+}
+
+// Validates Swift bridge is available before method calls
+- (void)assertBridgeAvailable:(NSString *)context {
+  RCT_ASSERT_BRIDGE_AVAILABLE(self.swiftBridge, context);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Use runtime class lookup to avoid import issues and circular dependencies
+    Class swiftClass = NSClassFromString(@"NativeMessagingPush");
+    RCT_ASSERT_NOT_NIL(swiftClass, @"NativeMessagingPush Swift class", @"during runtime lookup");
+    _swiftBridge = [[swiftClass alloc] init];
+    [self assertBridgeAvailable:@"creating NativeMessagingPush Swift instance"];
+  }
+  return self;
+}
+
+// Module initialization can happen on background thread
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)onMessageReceived:(NSDictionary *)message
+    handleNotificationTrigger:(BOOL)handleNotificationTrigger
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject {
+  [self assertBridgeAvailable:@"during handleMessage"];
+  [_swiftBridge onMessageReceived:message
+        handleNotificationTrigger:handleNotificationTrigger
+                          resolve:resolve
+                           reject:reject];
+}
+
+- (void)trackNotificationResponseReceived:(NSDictionary *)payload {
+  [self assertBridgeAvailable:@"during trackNotificationResponseReceived"];
+  [_swiftBridge trackNotificationResponseReceived:payload];
+}
+
+- (void)trackNotificationReceived:(NSDictionary *)payload {
+  [self assertBridgeAvailable:@"during trackNotificationReceived"];
+  [_swiftBridge trackNotificationReceived:payload];
+}
+
+- (void)getRegisteredDeviceToken:(RCTPromiseResolveBlock)resolve
+                          reject:(RCTPromiseRejectBlock)reject {
+  [self assertBridgeAvailable:@"during getRegisteredDeviceToken"];
+  [_swiftBridge getRegisteredDeviceToken:resolve reject:reject];
+}
+
+- (void)showPromptForPushNotifications:(NSDictionary *)options
+                               resolve:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject {
+  [self assertBridgeAvailable:@"during showPromptForPushNotifications"];
+  [_swiftBridge showPromptForPushNotifications:options resolve:resolve reject:reject];
+}
+
+- (void)getPushPermissionStatus:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  [self assertBridgeAvailable:@"during getPushPermissionStatus"];
+  [_swiftBridge getPushPermissionStatus:resolve reject:reject];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeCustomerIOMessagingPushCls(void) {
+  return RCTNativeMessagingPush.class;
+}
+
+@end

package/ios/wrappers/push/NativeMessagingPush.swift

@@ -0,0 +1,119 @@
+import CioInternalCommon
+import CioMessagingPush
+import Foundation
+
+enum PushPermissionStatus: String, CaseIterable {
+    case denied
+    case notDetermined
+    case granted
+
+    var value: String {
+        rawValue.uppercased()
+    }
+}
+
+@objc(NativeMessagingPush)
+public class NativeMessagingPush: NSObject {
+    private let logger: CioInternalCommon.Logger = DIGraphShared.shared.logger
+
+    @objc
+    public func onMessageReceived(
+        _ message: NSDictionary,
+        handleNotificationTrigger: Bool,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Preconditions.unsupportedOnIOS(methodName: "onMessageReceived")
+    }
+
+    // Tracks `opened` push metrics when a push notification is interacted with.
+    @objc
+    public func trackNotificationResponseReceived(_ payload: NSDictionary) {
+        trackPushMetrics(payload: payload, event: .opened)
+    }
+
+    // Tracks `delivered` push metrics when a push notification is received.
+    @objc
+    public func trackNotificationReceived(_ payload: NSDictionary) {
+        trackPushMetrics(payload: payload, event: .delivered)
+    }
+
+    // Get the currently registered device token for the app
+    @objc(getRegisteredDeviceToken:reject:)
+    public func getRegisteredDeviceToken(resolve: @escaping (RCTPromiseResolveBlock), reject: @escaping (RCTPromiseRejectBlock)) {
+        guard let token = CustomerIO.shared.registeredDeviceToken else {
+            reject(CustomerioConstants.cioTag, CustomerioConstants.showDeviceTokenFailureError, nil)
+            return
+        }
+        resolve(token)
+    }
+
+    private func trackPushMetrics(payload: NSDictionary, event: Metric) {
+        guard let deliveryId = payload[CustomerioConstants.CioDeliveryId] as? String,
+              let deviceToken = payload[CustomerioConstants.CioDeliveryToken] as? String
+        else { return }
+
+        MessagingPush.shared.trackMetric(deliveryID: deliveryId, event: event, deviceToken: deviceToken)
+    }
+
+    @objc(showPromptForPushNotifications:resolve:reject:)
+    public func showPromptForPushNotifications(options: [String: AnyHashable], resolve: @escaping (RCTPromiseResolveBlock), reject: @escaping (RCTPromiseRejectBlock)) {
+        // Show prompt if status is not determined
+        getPushNotificationPermissionStatus { status in
+            if status == .notDetermined {
+                self.requestPushAuthorization(options: options) { permissionStatus in
+                    guard let isGranted = permissionStatus as? Bool else {
+                        reject(CustomerioConstants.cioTag, CustomerioConstants.showPromptFailureError, permissionStatus as? Error)
+                        return
+                    }
+                    resolve(isGranted ? PushPermissionStatus.granted.value : PushPermissionStatus.denied.value)
+                }
+            } else {
+                resolve(status.value)
+            }
+        }
+    }
+
+    @objc(getPushPermissionStatus:reject:)
+    public func getPushPermissionStatus(resolve: @escaping (RCTPromiseResolveBlock), _: @escaping (RCTPromiseRejectBlock)) {
+        getPushNotificationPermissionStatus { status in
+            resolve(status.value)
+        }
+    }
+
+    private func requestPushAuthorization(options: [String: Any], onComplete: @escaping (Any) -> Void) {
+        let current = UNUserNotificationCenter.current()
+        var notificationOptions: UNAuthorizationOptions = [.alert]
+        if let ios = options[CustomerioConstants.platformiOS] as? [String: Any] {
+            if let soundOption = ios[CustomerioConstants.sound] as? Bool, soundOption {
+                notificationOptions.insert(.sound)
+            }
+            if let badgeOption = ios[CustomerioConstants.badge] as? Bool, badgeOption {
+                notificationOptions.insert(.badge)
+            }
+        }
+        current.requestAuthorization(options: notificationOptions) { isGranted, error in
+            if let error = error {
+                onComplete(error)
+                return
+            }
+            onComplete(isGranted)
+        }
+    }
+
+    private func getPushNotificationPermissionStatus(completionHandler: @escaping (PushPermissionStatus) -> Void) {
+        var status = PushPermissionStatus.notDetermined
+        let current = UNUserNotificationCenter.current()
+        current.getNotificationSettings(completionHandler: { permission in
+            switch permission.authorizationStatus {
+            case .authorized, .provisional, .ephemeral:
+                status = .granted
+            case .denied:
+                status = .denied
+            default:
+                status = .notDetermined
+            }
+            completionHandler(status)
+        })
+    }
+}

package/ios/wrappers/utils/CioConfigUtils.swift

@@ -0,0 +1,63 @@
+import CioDataPipelines
+import CioInternalCommon
+import CioMessagingInApp
+
+enum SDKConfigBuilderError: Error {
+    case missingCdpApiKey
+}
+
+extension SDKConfigBuilder {
+    private enum Config: String {
+        case migrationSiteId
+        case cdpApiKey
+        case region
+        case logLevel
+        case apiHost
+        case cdnHost
+        case flushAt
+        case flushInterval
+        case screenViewUse
+        case trackApplicationLifecycleEvents
+        case autoTrackDeviceAttributes
+    }
+
+    @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
+        }
+
+        let builder = SDKConfigBuilder(cdpApiKey: cdpApiKey)
+        Config.migrationSiteId.ifNotNil(in: config, thenPassItTo: builder.migrationSiteId)
+        Config.region.ifNotNil(in: config, thenPassItTo: builder.region, transformingBy: Region.getRegion)
+        Config.logLevel.ifNotNil(in: config, thenPassItTo: builder.logLevel, transformingBy: CioLogLevel.getLogLevel)
+        Config.flushAt.ifNotNil(in: config, thenPassItTo: builder.flushAt) { (value: Double) in Int(value) }
+        Config.flushInterval.ifNotNil(in: config, thenPassItTo: builder.flushInterval)
+        Config.screenViewUse.ifNotNil(in: config, thenPassItTo: builder.screenViewUse) { ScreenView.getScreenView($0) }
+        Config.trackApplicationLifecycleEvents.ifNotNil(in: config, thenPassItTo: builder.trackApplicationLifecycleEvents)
+        Config.autoTrackDeviceAttributes.ifNotNil(in: config, thenPassItTo: builder.autoTrackDeviceAttributes)
+        Config.apiHost.ifNotNil(in: config, thenPassItTo: builder.apiHost)
+        Config.cdnHost.ifNotNil(in: config, thenPassItTo: builder.cdnHost)
+
+        return builder
+    }
+}
+
+extension RawRepresentable where RawValue == String {
+    func ifNotNil<Raw>(
+        in config: [String: Any?]?,
+        thenPassItTo handler: (Raw) -> Any
+    ) {
+        ifNotNil(in: config, thenPassItTo: handler) { $0 }
+    }
+
+    func ifNotNil<Raw, Transformed>(
+        in config: [String: Any?]?,
+        thenPassItTo handler: (Transformed) -> Any,
+        transformingBy transform: (Raw) -> Transformed?
+    ) {
+        if let value = config?[rawValue] as? Raw, let result = transform(value) {
+            _ = handler(result)
+        }
+    }
+}

package/ios/wrappers/utils/CioConstants.swift

@@ -0,0 +1,25 @@
+enum CustomerioConstants {
+    // InApp Messaging
+    static let inAppEventListener = "InAppEventListener"
+    static let eventType = "eventType"
+    static let messageId = "messageId"
+    static let deliveryId = "deliveryId"
+    static let actionValue = "actionValue"
+    static let actionName = "actionName"
+    static let messageShown = "messageShown"
+    static let messageDismissed = "messageDismissed"
+    static let errorWithMessage = "errorWithMessage"
+    static let messageActionTaken = "messageActionTaken"
+
+    // Push Messaging
+    static let CioDeliveryId = "CIO-Delivery-ID"
+    static let CioDeliveryToken = "CIO-Delivery-Token"
+    static let showPromptFailureError = "Error requesting push notification permission."
+    static let showDeviceTokenFailureError = "Error fetching registered device token."
+    static let platformiOS = "ios"
+    static let sound = "sound"
+    static let badge = "badge"
+
+    // Logging
+    static let cioTag = "[CIO]"
+}

package/ios/wrappers/utils/Preconditions.swift

@@ -0,0 +1,20 @@
+import CioInternalCommon
+import Foundation
+
+/// Preconditions and utility functions for React Native wrapper
+public enum Preconditions {
+    /// Throws a runtime exception in debug builds and logs a warning in release builds if a method
+    /// that is only supported on Android is called from iOS.
+    ///
+    /// Use this to guard any platform-specific methods that are not expected to called on iOS from TypeScript.
+    public static func unsupportedOnIOS(methodName: String) {
+        let message = "'\(methodName)' is unsupported on iOS and should not be called."
+
+        #if DEBUG
+        fatalError(message)
+        #else
+        let logger = DIGraphShared.shared.logger
+        logger.error(message)
+        #endif
+    }
+}