@dashx/react-native 1.4.1 → 1.5.0

package/.claude/worktrees/autocapture-conventions-review-78f665/ios/DashXNotificationHandler.swift

@@ -0,0 +1,301 @@
+import Foundation
+import UIKit
+import UserNotifications
+import DashX
+import FirebaseMessaging
+
+/// The result of handling a notification response.
+/// Consumers can use `url` to navigate and `actionIdentifier` for custom action handling.
+@objc(DashXNotificationResponseResult)
+public final class DashXNotificationResponseResult: NSObject {
+    @objc public let userInfo: [AnyHashable: Any]
+    @objc public let actionIdentifier: String
+    /// The DashX notification URL, if present in the payload.
+    @objc public let url: URL?
+    /// The resolved navigation intent for the tap / action button.
+    /// Non-@objc (the enum isn't representable in Obj-C); read via Swift.
+    public let navigationAction: NavigationAction?
+
+    init(userInfo: [AnyHashable: Any], actionIdentifier: String, url: URL?, navigationAction: NavigationAction?) {
+        self.userInfo = userInfo
+        self.actionIdentifier = actionIdentifier
+        self.url = url
+        self.navigationAction = navigationAction
+    }
+}
+
+@objc(DashXNotificationHandler)
+public final class DashXNotificationHandler: NSObject {
+
+    @objc
+    public static func handleRemoteNotification(
+        userInfo: [AnyHashable: Any],
+        completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) {
+        Messaging.messaging().appDidReceiveMessage(userInfo)
+
+        DashXEventEmitter.instance.dispatch(
+            name: "messageReceived",
+            body: bridgeSafePayload(from: userInfo)
+        )
+
+        // Alert pushes (aps.alert present) are displayed by iOS directly via
+        // the Notification Service Extension. Skipping the silent-push
+        // reconstruction prevents a duplicate `add()` from racing the
+        // system-displayed banner and clobbering its NSE-attached image.
+        if let aps = userInfo["aps"] as? [AnyHashable: Any], aps["alert"] != nil {
+            completionHandler(.newData)
+            return
+        }
+
+        guard let dashxData = userInfo.dashxNotificationData() else {
+            completionHandler(.noData)
+            return
+        }
+
+        DashX.trackMessage(message: userInfo, event: .delivered)
+
+        let content = UNMutableNotificationContent()
+        content.sound = UNNotificationSound.default
+        content.title = dashxData.title
+        content.body = dashxData.body
+        content.userInfo = userInfo
+        content.categoryIdentifier = Constants.DASHX_NOTIFICATION_CATEGORY_IDENTIFIER
+
+        var actions: [UNNotificationAction] = []
+        if let actionButtons = dashxData.actionButtons {
+            for button in actionButtons {
+                actions.append(
+                    UNNotificationAction(
+                        identifier: button.identifier,
+                        title: button.label,
+                        options: [.foreground]
+                    )
+                )
+            }
+        }
+
+        let category = UNNotificationCategory(
+            identifier: Constants.DASHX_NOTIFICATION_CATEGORY_IDENTIFIER,
+            actions: actions,
+            intentIdentifiers: [],
+            options: .customDismissAction
+        )
+        UNUserNotificationCenter.current().setNotificationCategories([category])
+
+        // Defer the completion handler until after the local notification has
+        // actually been added. iOS suspends the process the moment we call
+        // `completionHandler`, so firing it before the async download + add
+        // chain finishes was dropping notifications mid-flight. The 25s budget
+        // sits comfortably under iOS's ~30s background-push limit.
+        let fire = makeOnceFire(completionHandler)
+        DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(25)) {
+            fire(.newData)
+        }
+
+        if let imagePath = dashxData.image, let imageURL = URL(string: imagePath) {
+            createNotificationWithImage(id: dashxData.id, imageURL: imageURL, content: content) {
+                fire(.newData)
+            }
+        } else {
+            createNotification(id: dashxData.id, content: content) {
+                fire(.newData)
+            }
+        }
+    }
+
+    /// Wraps `completionHandler` so it can be invoked safely from any of the
+    /// (download done) / (add done) / (timeout) callbacks — second invocation
+    /// is a no-op.
+    private static func makeOnceFire(
+        _ completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) -> (UIBackgroundFetchResult) -> Void {
+        let lock = NSLock()
+        var fired = false
+        return { result in
+            lock.lock()
+            defer { lock.unlock() }
+            guard !fired else { return }
+            fired = true
+            completionHandler(result)
+        }
+    }
+
+    @objc
+    @discardableResult
+    public static func handleNotificationResponse(_ response: UNNotificationResponse) -> DashXNotificationResponseResult {
+        let userInfo = response.notification.request.content.userInfo
+
+        Messaging.messaging().appDidReceiveMessage(userInfo)
+
+        DashXEventEmitter.instance.dispatch(
+            name: "messageReceived",
+            body: bridgeSafePayload(from: userInfo)
+        )
+
+        if response.actionIdentifier == UNNotificationDismissActionIdentifier {
+            DashX.trackMessage(message: userInfo, event: .dismissed)
+        } else {
+            DashX.trackMessage(message: userInfo, event: .clicked)
+        }
+
+        let notificationUrl = userInfo.dashxNotificationUrl()
+        let dashxData = userInfo.dashxNotificationData()
+        let navigationAction = dashxData?.navigationAction(forActionIdentifier: response.actionIdentifier)
+
+        if response.actionIdentifier != UNNotificationDismissActionIdentifier {
+            DashXEventEmitter.instance.dispatch(
+                name: "notificationClicked",
+                body: [
+                    "notification": bridgeSafePayload(from: userInfo),
+                    "action": jsonDictionary(from: navigationAction) ?? NSNull(),
+                    "actionIdentifier": response.actionIdentifier,
+                ]
+            )
+        }
+
+        return DashXNotificationResponseResult(
+            userInfo: userInfo,
+            actionIdentifier: response.actionIdentifier,
+            url: notificationUrl,
+            navigationAction: navigationAction
+        )
+    }
+
+    // MARK: - Device Token
+
+    /// Bridges the APNS device token to Firebase Cloud Messaging and registers
+    /// the FCM token with DashX. Call this from
+    /// `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)`.
+    @objc
+    public static func handleDeviceToken(_ deviceToken: Data) {
+        // Force the APNs environment explicitly rather than using `.unknown`
+        // (auto-detect). Firebase's auto-detection reads the token's aps
+        // entitlement from the signed binary and sometimes mis-tags dev
+        // builds as production, producing an FCM token whose pushes silently
+        // fail at APNs with 410 Unregistered.
+        #if DEBUG
+        Messaging.messaging().setAPNSToken(deviceToken, type: .sandbox)
+        #else
+        Messaging.messaging().setAPNSToken(deviceToken, type: .prod)
+        #endif
+        Messaging.messaging().token { token, error in
+            if let token = token {
+                DashX.setFCMToken(to: token)
+            }
+        }
+    }
+
+    // MARK: - Foreground Notification
+
+    /// Handles a notification that arrived while the app is in the foreground.
+    /// Tracks the delivery event, emits `messageReceived` to JS, forwards to
+    /// Firebase analytics, and presents the notification as a banner with sound.
+    /// Call this from `userNotificationCenter(_:willPresent:withCompletionHandler:)`.
+    @objc
+    public static func handleForegroundNotification(
+        _ notification: UNNotification,
+        completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+    ) {
+        let userInfo = notification.request.content.userInfo
+
+        Messaging.messaging().appDidReceiveMessage(userInfo)
+
+        DashX.trackMessage(message: userInfo, event: .delivered)
+
+        DashXEventEmitter.instance.dispatch(
+            name: "messageReceived",
+            body: bridgeSafePayload(from: userInfo)
+        )
+
+        completionHandler([.banner, .sound])
+    }
+
+    // MARK: - Private Helpers
+
+    private static func createNotification(
+        id: String,
+        content: UNMutableNotificationContent,
+        completion: @escaping () -> Void
+    ) {
+        let request = UNNotificationRequest(identifier: id, content: content, trigger: nil)
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                DashXLog.d(tag: #function, "Failed to schedule notification: \(error.localizedDescription)")
+            }
+            completion()
+        }
+    }
+
+    private static func createNotificationWithImage(
+        id: String,
+        imageURL: URL,
+        content: UNMutableNotificationContent,
+        completion: @escaping () -> Void
+    ) {
+        let task = URLSession.shared.downloadTask(with: imageURL) { location, _, error in
+            guard let location = location, error == nil else {
+                createNotification(id: id, content: content, completion: completion)
+                return
+            }
+
+            let tmpDir = FileManager.default.temporaryDirectory
+            let tmpFile = tmpDir.appendingPathComponent(UUID().uuidString + ".png")
+
+            do {
+                try FileManager.default.moveItem(at: location, to: tmpFile)
+                let attachment = try UNNotificationAttachment(
+                    identifier: "\(id)-attachment",
+                    url: tmpFile,
+                    options: nil
+                )
+                content.attachments = [attachment]
+            } catch {
+                // fall through with no attachment
+            }
+            createNotification(id: id, content: content, completion: completion)
+        }
+        task.resume()
+    }
+
+    /// Serializes a ``NavigationAction`` into the JS-bridge shape mirrored by
+    /// `NavigationAction` in `index.d.ts`. Returns `nil` for `nil` input.
+    private static func jsonDictionary(from action: NavigationAction?) -> [String: Any]? {
+        guard let action else { return nil }
+        switch action {
+        case .deepLink(let url):
+            return ["type": "deepLink", "url": url.absoluteString]
+        case .screen(let name, let data):
+            var dict: [String: Any] = ["type": "screen", "name": name]
+            if let data { dict["data"] = data }
+            return dict
+        case .richLanding(let url):
+            return ["type": "richLanding", "url": url.absoluteString]
+        case .clickAction(let actionString):
+            return ["type": "clickAction", "action": actionString]
+        }
+    }
+
+    private static func bridgeSafePayload(from userInfo: [AnyHashable: Any]) -> [String: Any] {
+        userInfo.reduce(into: [String: Any]()) { result, pair in
+            let key = String(describing: pair.key)
+            let value = pair.value
+            if let str = value as? String {
+                result[key] = str
+            } else if let num = value as? NSNumber {
+                result[key] = num
+            } else if let dict = value as? [AnyHashable: Any] {
+                result[key] = bridgeSafePayload(from: dict)
+            } else if let arr = value as? [Any] {
+                result[key] = arr.map { item -> Any in
+                    if let str = item as? String { return str }
+                    if let num = item as? NSNumber { return num }
+                    if let d = item as? [AnyHashable: Any] { return bridgeSafePayload(from: d) }
+                    return "\(item)"
+                }
+            } else {
+                result[key] = "\(value)"
+            }
+        }
+    }
+}

package/.claude/worktrees/autocapture-conventions-review-78f665/ios/DashXReactNative-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>

package/.claude/worktrees/autocapture-conventions-review-78f665/ios/DashXReactNative.mm

@@ -0,0 +1,77 @@
+//
+// AUTO-GENERATED FROM DashXReactNative.swift — DO NOT EDIT.
+// Regenerate with `yarn sync-bridge-shim` after editing the Swift file.
+//
+// The Swift class's @objc method declarations are the source of truth.
+// This file mirrors them so old-arch React Native consumers (which discover
+// methods via RCT_EXTERN_METHOD) and new-arch consumers (which dispatch via
+// the codegen-generated TurboModule spec) both find consistent signatures.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNDashXReactNativeSpec.h"
+#endif
+
+@interface RCT_EXTERN_MODULE(DashXReactNative, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(configure:(NSDictionary *)options);
+
+RCT_EXTERN_METHOD(identify:(NSDictionary *)options);
+
+RCT_EXTERN_METHOD(setIdentity:(NSString * _Nullable)uid token:(NSString * _Nullable)token);
+
+RCT_EXTERN_METHOD(reset);
+
+RCT_EXTERN_METHOD(track:(NSString *)event data:(NSDictionary * _Nullable)data);
+
+RCT_EXTERN_METHOD(screen:(NSString *)screenName data:(NSDictionary * _Nullable)data);
+
+RCT_EXTERN_METHOD(fetchRecord:(NSString *)urn options:(NSDictionary * _Nullable)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(searchRecords:(NSString *)resource options:(NSDictionary * _Nullable)options resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(fetchStoredPreferences:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(saveStoredPreferences:(NSDictionary *)preferenceData resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(subscribe);
+
+RCT_EXTERN_METHOD(unsubscribe:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(setLogLevel:(double)level);
+
+RCT_EXTERN_METHOD(uploadAsset:(NSString *)filePath resource:(NSString *)resource attribute:(NSString *)attribute resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(fetchAsset:(NSString *)assetId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(enableLifecycleTracking);
+
+RCT_EXTERN_METHOD(enableAdTracking);
+
+RCT_EXTERN_METHOD(processURL:(NSString *)url source:(NSString * _Nullable)source forwardToLinkHandler:(BOOL)forwardToLinkHandler);
+
+RCT_EXTERN_METHOD(trackNotificationNavigation:(NSDictionary * _Nullable)action notificationId:(NSString * _Nullable)notificationId);
+
+RCT_EXTERN_METHOD(requestNotificationPermission:(BOOL)fallbackToSettings resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+RCT_EXTERN_METHOD(getNotificationPermissionStatus:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject);
+
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface DashXReactNative () <NativeDashXReactNativeSpec>
+@end
+
+@implementation DashXReactNative (TurboModule)
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeDashXReactNativeSpecJSI>(params);
+}
+
+@end
+#endif

package/.claude/worktrees/autocapture-conventions-review-78f665/ios/DashXReactNative.swift

@@ -0,0 +1,244 @@
+import Foundation
+import DashX
+
+@objc(DashXReactNative)
+class DashXReactNative: RCTEventEmitter {
+    override init() {
+        super.init()
+        DashXEventEmitter.instance.registerEventEmitter(eventEmitter: self)
+        DashX.linkHandler = { url in
+            DashXEventEmitter.instance.dispatch(name: "linkReceived", body: url.absoluteString)
+        }
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override func supportedEvents() -> [String] {
+        return ["messageReceived", "linkReceived", "notificationClicked"]
+    }
+
+    @objc(configure:)
+    func configure(_ options: NSDictionary) {
+        guard let publicKey = options["publicKey"] as? String, !publicKey.isEmpty else {
+            return
+        }
+        let baseURI = options["baseURI"] as? String
+        let targetEnvironment = options["targetEnvironment"] as? String
+
+        DashX.configure(
+            withPublicKey: publicKey,
+            baseURI: baseURI,
+            targetEnvironment: targetEnvironment
+        )
+    }
+
+    @objc(identify:)
+    func identify(_ options: NSDictionary) {
+        let stringOptions = (options as? [String: Any])?.compactMapValues { ($0 as? CustomStringConvertible)?.description } ?? [:]
+        try? DashX.identify(options: stringOptions)
+    }
+
+    @objc(setIdentity:token:)
+    func setIdentity(_ uid: NSString?, _ token: NSString?) {
+        DashX.setIdentity(uid: uid as String?, token: token as String?)
+    }
+
+    @objc
+    func reset() {
+        DashX.reset()
+    }
+
+    @objc(track:data:)
+    func track(_ event: String, _ data: NSDictionary?) {
+        DashX.track(event, withData: data as? [String: Any])
+    }
+
+    @objc(screen:data:)
+    func screen(_ screenName: String, _ data: NSDictionary?) {
+        DashX.screen(screenName, withData: data as? [String: Any])
+    }
+
+    @objc(fetchRecord:options:resolve:reject:)
+    func fetchRecord(_ urn: String, options: NSDictionary?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashXClient.instance.fetchRecord(
+            urn: urn,
+            preview: options?["preview"] as? Bool,
+            language: options?["language"] as? String,
+            fields: options?["fields"] as? [[String: Any]],
+            include: options?["include"] as? [[String: Any]],
+            exclude: options?["exclude"] as? [[String: Any]]
+        ) { result in
+            switch result {
+            case .success(let record): resolve(record)
+            case .failure(let error): reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(searchRecords:options:resolve:reject:)
+    func searchRecords(_ resource: String, options: NSDictionary?, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashXClient.instance.searchRecords(
+            resource: resource,
+            filter: options?["filter"] as? [String: Any],
+            order: options?["order"] as? [[String: Any]],
+            limit: options?["limit"] as? Int,
+            page: options?["page"] as? Int,
+            preview: options?["preview"] as? Bool,
+            language: options?["language"] as? String,
+            fields: options?["fields"] as? [[String: Any]],
+            include: options?["include"] as? [[String: Any]],
+            exclude: options?["exclude"] as? [[String: Any]]
+        ) { result in
+            switch result {
+            case .success(let records): resolve(records)
+            case .failure(let error): reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(fetchStoredPreferences:reject:)
+    func fetchStoredPreferences(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashXClient.instance.fetchStoredPreferences { result in
+            switch result {
+            case .success(let prefs): resolve(prefs)
+            case .failure(let error): reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(saveStoredPreferences:resolve:reject:)
+    func saveStoredPreferences(_ preferenceData: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        guard let dict = preferenceData as? [String: Any] else {
+            reject("EINVAL", "preferenceData must be a plain object", nil)
+            return
+        }
+        DashXClient.instance.saveStoredPreferences(preferenceData: dict) { result in
+            switch result {
+            case .success(let success): resolve(success)
+            case .failure(let error): reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc
+    func subscribe() {
+        DashX.subscribe()
+    }
+
+    @objc(unsubscribe:reject:)
+    func unsubscribe(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashX.unsubscribe { result in
+            switch result {
+            case .success(let didUnsubscribe):
+                resolve(["success": didUnsubscribe])
+            case .failure(let error):
+                reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(setLogLevel:)
+    func setLogLevel(_ level: Double) {
+        // JS contract: 0 = off, 1 = errors, 2 = debug
+        // Native SDK:  off = -1, error = 0, info = 1, debug = 2
+        let logLevel: DashXLog.LogLevel
+        switch Int(level) {
+        case 0: logLevel = .off
+        case 1: logLevel = .error
+        case 2: logLevel = .debug
+        default: logLevel = .off
+        }
+        DashXLog.setLogLevel(to: logLevel)
+    }
+
+    @objc(uploadAsset:resource:attribute:resolve:reject:)
+    func uploadAsset(_ filePath: String, resource: String, attribute: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        let fileURL = URL(fileURLWithPath: filePath)
+        DashXClient.instance.uploadAsset(fileURL: fileURL, resource: resource, attribute: attribute) { result in
+            switch result {
+            case .success(let assetResponse):
+                if let data = try? JSONEncoder().encode(assetResponse),
+                   let dict = try? JSONSerialization.jsonObject(with: data) as? NSDictionary {
+                    resolve(dict)
+                } else {
+                    resolve(nil)
+                }
+            case .failure(let error):
+                reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(fetchAsset:resolve:reject:)
+    func fetchAsset(_ assetId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashXClient.instance.fetchAsset(assetId: assetId) { result in
+            switch result {
+            case .success(let assetResponse):
+                if let data = try? JSONEncoder().encode(assetResponse),
+                   let dict = try? JSONSerialization.jsonObject(with: data) as? NSDictionary {
+                    resolve(dict)
+                } else {
+                    resolve(nil)
+                }
+            case .failure(let error):
+                reject("EUNSPECIFIED", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc
+    func enableLifecycleTracking() {
+        DispatchQueue.main.async { DashX.enableLifecycleTracking() }
+    }
+
+    @objc
+    func enableAdTracking() {
+        DashX.enableAdTracking()
+    }
+
+    @objc(processURL:source:forwardToLinkHandler:)
+    func processURL(_ url: String, source: NSString?, forwardToLinkHandler: Bool) {
+        guard let parsedURL = URL(string: url) else { return }
+        DashX.processURL(parsedURL, source: source as String?, forwardToLinkHandler: forwardToLinkHandler)
+    }
+
+    @objc(trackNotificationNavigation:notificationId:)
+    func trackNotificationNavigation(_ action: NSDictionary?, notificationId: NSString?) {
+        var navigationAction: NavigationAction? = nil
+        if let action = action, let type = action["type"] as? String {
+            switch type {
+            case "deepLink":
+                if let urlString = action["url"] as? String, let url = URL(string: urlString) {
+                    navigationAction = .deepLink(url: url)
+                }
+            case "screen":
+                if let name = action["name"] as? String {
+                    navigationAction = .screen(name: name, data: action["data"] as? [String: String])
+                }
+            case "richLanding":
+                if let urlString = action["url"] as? String, let url = URL(string: urlString) {
+                    navigationAction = .richLanding(url: url)
+                }
+            case "clickAction":
+                if let actionStr = action["action"] as? String {
+                    navigationAction = .clickAction(action: actionStr)
+                }
+            default:
+                break
+            }
+        }
+        DashX.trackNotificationNavigation(navigationAction, notificationId: notificationId as String?)
+    }
+
+    @objc(requestNotificationPermission:resolve:reject:)
+    func requestNotificationPermission(_ fallbackToSettings: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashX.requestNotificationPermission(fallbackToSettings: fallbackToSettings) { status in resolve(status.rawValue) }
+    }
+
+    @objc(getNotificationPermissionStatus:reject:)
+    func getNotificationPermissionStatus(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        DashX.getNotificationPermissionStatus { status in resolve(status.rawValue) }
+    }
+}