@primer-io/react-native 2.16.7 → 2.17.0-rc.10

package/ios/Sources/Headless Universal Checkout/Managers/RNTAssetsManager.swift

@@ -0,0 +1,107 @@
+//
+//  RNTAssetsManager.swift
+//  primer-io-react-native
+//
+//  Created by Evangelos on 6/10/22.
+//
+
+import Foundation
+import PrimerSDK
+
+@objc(RNTPrimerHeadlessUniversalCheckoutAssetsManager)
+class RNTPrimerHeadlessUniversalCheckoutAssetsManager: RCTEventEmitter {
+
+    override func supportedEvents() -> [String]! {
+        return []
+    }
+
+    override class func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    func getCardNetworkImage(
+        _ cardNetworkStr: String,
+        resolver: RCTPromiseResolveBlock,
+        rejecter: RCTPromiseRejectBlock
+    ) {
+        do {
+
+            guard let cardNetwork = CardNetwork(rawValue: cardNetworkStr) else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Failed to find asset of \(cardNetworkStr).",
+                    recoverySuggestion: nil)
+                throw err
+            }
+
+            guard let cardNetworkImage = try PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager.getCardNetworkImage(for: cardNetwork) else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Failed to find asset of \(cardNetworkStr).",
+                    recoverySuggestion: nil)
+                throw err
+            }
+
+            let localUrl = try cardNetworkImage.store(withName: cardNetwork.rawValue)
+            resolver(["cardNetworkImageURL": localUrl.absoluteString])
+
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+
+    @objc
+    func getPaymentMethodAsset(
+        _ paymentMethodType: String,
+        resolver: RCTPromiseResolveBlock,
+        rejecter: RCTPromiseRejectBlock
+    ) {
+        do {
+            guard let paymentMethodAsset = try PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager.getPaymentMethodAsset(for: paymentMethodType) else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Failed to find asset of \(paymentMethodType) for this session",
+                    recoverySuggestion: nil)
+                throw err
+            }
+
+            if let rntPaymentMethodAsset = try? RNTPrimerPaymentMethodAsset(primerPaymentMethodAsset: paymentMethodAsset).toJsonObject() {
+                resolver(["paymentMethodAsset": rntPaymentMethodAsset])
+            } else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Failed to create the RNTPrimerPaymentMethodAsset",
+                    recoverySuggestion: nil)
+                throw err
+            }
+
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+
+    @objc
+    func getPaymentMethodAssets(
+        _ resolver: RCTPromiseResolveBlock,
+        rejecter: RCTPromiseRejectBlock
+    ) {
+        do {
+            let paymentMethodAssets = try PrimerSDK.PrimerHeadlessUniversalCheckout.AssetsManager.getPaymentMethodAssets()
+
+            let rntPaymentMethodAssets = paymentMethodAssets.compactMap({ try? RNTPrimerPaymentMethodAsset(primerPaymentMethodAsset: $0).toJsonObject() })
+            guard !rntPaymentMethodAssets.isEmpty else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Failed to find assets for this session",
+                    recoverySuggestion: nil)
+                throw err
+            }
+
+            resolver(["paymentMethodAssets": rntPaymentMethodAssets])
+
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+}

package/ios/Sources/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckout.m

@@ -0,0 +1,41 @@
+//
+//  RNTPrimerHeadlessUniversalCheckout.m
+//  primer-io-react-native
+//
+//  Created by Evangelos on 8/3/22.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(PrimerHeadlessUniversalCheckout, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(startWithClientToken:(NSString *)clientToken
+                  settingsStr:(NSString *)settingsStr
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter: (RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(cleanUp:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+// MARK: - DECISION HANDLERS
+
+// MARK: Tokenization & Resume Handlers
+
+RCT_EXTERN_METHOD(handleTokenizationNewClientToken:(NSString *)newClientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(handleResumeWithNewClientToken:(NSString *)newClientToken resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(handleCompleteFlow:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+// MARK: Payment Creation Handlers
+
+RCT_EXTERN_METHOD(handlePaymentCreationAbort:(NSString *)errorMessage resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(handlePaymentCreationContinue:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+// MARK: - HELPERS
+
+RCT_EXTERN_METHOD(setImplementedRNCallbacks:(NSString *)implementedRNCallbacksStr resolver:(RCTPromiseResolveBlock)resolver rejecter:(RCTPromiseRejectBlock)rejecter)
+
+
+@end

package/ios/Sources/Headless Universal Checkout/RNTPrimerHeadlessUniversalCheckout.swift

@@ -0,0 +1,498 @@
+//
+//  RNTPrimerHeadlessUniversalCheckout.swift
+//  primer-io-react-native
+//
+//  Created by Evangelos on 8/3/22.
+//
+
+import Foundation
+import PrimerSDK
+
+@objc
+enum PrimerHeadlessUniversalCheckoutEvents: Int, CaseIterable {
+
+    // Delegate
+    case onAvailablePaymentMethodsLoad = 0
+    case onTokenizationStart
+    case onTokenizationSuccess
+    case onCheckoutResume
+    case onCheckoutPending
+    case onCheckoutAdditionalInfo
+    case onError
+    case onCheckoutComplete
+    case onBeforeClientSessionUpdate
+    case onClientSessionUpdate
+    case onBeforePaymentCreate
+
+    // UI Delegate
+    case onPreparationStart
+    case onPaymentMethodShow
+
+    var stringValue: String {
+        switch self {
+        case .onAvailablePaymentMethodsLoad:
+            return "onAvailablePaymentMethodsLoad"
+        case .onTokenizationStart:
+            return "onTokenizationStart"
+        case .onTokenizationSuccess:
+            return "onTokenizationSuccess"
+        case .onCheckoutResume:
+            return "onCheckoutResume"
+        case .onCheckoutPending:
+            return "onCheckoutPending"
+        case .onCheckoutAdditionalInfo:
+            return "onCheckoutAdditionalInfo"
+        case .onError:
+            return "onError"
+        case .onBeforeClientSessionUpdate:
+            return "onBeforeClientSessionUpdate"
+        case .onCheckoutComplete:
+            return "onCheckoutComplete"
+        case .onBeforePaymentCreate:
+            return "onBeforePaymentCreate"
+        case .onClientSessionUpdate:
+            return "onClientSessionUpdate"
+        case .onPreparationStart:
+            return "onPreparationStart"
+        case .onPaymentMethodShow:
+            return "onPaymentMethodShow"
+        }
+    }
+}
+
+@objc(PrimerHeadlessUniversalCheckout)
+class RNTPrimerHeadlessUniversalCheckout: RCTEventEmitter {
+
+    private var settings: PrimerSettings?
+    private var primerWillCreatePaymentWithDataDecisionHandler: ((_ errorMessage: String?) -> Void)?
+    private var primerDidTokenizePaymentMethodDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var primerDidResumeWithDecisionHandler: ((_ resumeToken: String?, _ errorMessage: String?) -> Void)?
+    private var implementedRNCallbacks: ImplementedRNCallbacks?
+
+    override class func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override init() {
+        super.init()
+        PrimerHeadlessUniversalCheckout.current.delegate = self
+        PrimerHeadlessUniversalCheckout.current.uiDelegate = self
+    }
+
+    override func supportedEvents() -> [String]! {
+        return PrimerHeadlessUniversalCheckoutEvents.allCases.compactMap({ $0.stringValue })
+    }
+
+    // MARK: - API
+
+    @objc
+    public func startWithClientToken(_ clientToken: String,
+                                     settingsStr: String?,
+                                     resolver: @escaping RCTPromiseResolveBlock,
+                                     rejecter: @escaping RCTPromiseRejectBlock)
+    {
+        do {
+            var tmpSettings: PrimerSettings?
+            if let settingsStr = settingsStr {
+                tmpSettings = try PrimerSettings(settingsStr: settingsStr)
+                self.settings = tmpSettings
+            }
+
+            PrimerHeadlessUniversalCheckout.current.start(
+                withClientToken: clientToken,
+                settings: settings,
+                delegate: self,
+                uiDelegate: self) { paymentMethods, err in
+                    if let err = err {
+                        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+                    } else if let paymentMethods = paymentMethods {
+                        let paymentMethodObjects = paymentMethods.compactMap({ $0.toJsonObject() })
+                        resolver(["availablePaymentMethods": paymentMethodObjects])
+                    }
+                }
+
+        } catch {
+            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+        }
+    }
+
+    @objc
+    public func cleanUp(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            PrimerHeadlessUniversalCheckout.current.cleanUp()
+            resolver(nil)
+        }
+    }
+
+    // MARK: - DECISION HANDLERS
+
+    // MARK: Tokenization & Resume Handlers
+
+    @objc
+    public func handleTokenizationNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidTokenizePaymentMethodDecisionHandler?(newClientToken, nil)
+            self.primerDidTokenizePaymentMethodDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+
+    @objc
+    public func handleResumeWithNewClientToken(_ newClientToken: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidResumeWithDecisionHandler?(newClientToken, nil)
+            self.primerDidResumeWithDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+
+    @objc
+    public func handleCompleteFlow(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerDidResumeWithDecisionHandler?(nil, nil)
+            self.primerDidResumeWithDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+
+    // MARK: Payment Creation
+
+    @objc
+    public func handlePaymentCreationAbort(_ errorMessage: String?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerWillCreatePaymentWithDataDecisionHandler?(errorMessage ?? "")
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+
+    @objc
+    public func handlePaymentCreationContinue(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            self.primerWillCreatePaymentWithDataDecisionHandler?(nil)
+            self.primerWillCreatePaymentWithDataDecisionHandler = nil
+            resolver(nil)
+        }
+    }
+
+    // MARK: Helpers
+
+    private func detectImplemetedCallbacks() {
+        sendEvent(withName: PrimerEvents.detectImplementedRNCallbacks.stringValue, body: nil)
+    }
+
+    @objc
+    public func setImplementedRNCallbacks(_ implementedRNCallbacksStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            do {
+                guard let implementedRNCallbacksData = implementedRNCallbacksStr.data(using: .utf8) else {
+                    let err = RNTNativeError(
+                        errorId: "native-ios",
+                        errorDescription: "Failed to convert string to data",
+                        recoverySuggestion: nil)
+                    throw err
+                }
+                self.implementedRNCallbacks = try JSONDecoder().decode(ImplementedRNCallbacks.self, from: implementedRNCallbacksData)
+                resolver(nil)
+            } catch {
+                self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: false)
+                rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+            }
+        }
+    }
+
+    private func handleRNBridgeError(_ error: Error, checkoutData: PrimerCheckoutData?, stopOnDebug: Bool) {
+        DispatchQueue.main.async {
+            if stopOnDebug {
+                assertionFailure(error.localizedDescription)
+            }
+
+            var body: [String: Any] = ["error": error.rnError]
+            if let checkoutData = checkoutData,
+               let data = try? JSONEncoder().encode(checkoutData),
+               let json = try? JSONSerialization.jsonObject(with: data){
+                body["checkoutData"] = json
+            }
+
+            self.sendEvent(withName: PrimerHeadlessUniversalCheckoutEvents.onError.stringValue, body: body)
+        }
+    }
+}
+
+// MARK: - EVENTS
+
+extension RNTPrimerHeadlessUniversalCheckout: PrimerHeadlessUniversalCheckoutDelegate {
+
+    // case onAvailablePaymentMethodsLoad = 0
+    func primerHeadlessUniversalCheckoutDidLoadAvailablePaymentMethods(_ paymentMethods: [PrimerHeadlessUniversalCheckout.PaymentMethod]) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onAvailablePaymentMethodsLoad.stringValue
+
+        DispatchQueue.main.async {
+            self.sendEvent(
+                withName: rnCallbackName,
+                body: ["availablePaymentMethods": paymentMethods.compactMap({ $0.toJsonObject() })])
+        }
+    }
+
+    // case onTokenizationStart
+    func primerHeadlessUniversalCheckoutDidStartTokenization(for paymentMethodType: String) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onTokenizationStart.stringValue
+
+        DispatchQueue.main.async {
+            self.sendEvent(
+                withName: rnCallbackName,
+                body: ["paymentMethodType": paymentMethodType])
+        }
+    }
+
+    // case onTokenizationSuccess
+    func primerHeadlessUniversalCheckoutDidTokenizePaymentMethod(_ paymentMethodTokenData: PrimerPaymentMethodTokenData, decisionHandler: @escaping (PrimerHeadlessUniversalCheckoutResumeDecision) -> Void) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onTokenizationSuccess.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnTokenizationSuccessImplemented == true {
+                self.primerDidTokenizePaymentMethodDecisionHandler = { (newClientToken, errorMessage) in
+                    DispatchQueue.main.async {
+                        if let newClientToken = newClientToken {
+                            decisionHandler(.continueWithNewClientToken(newClientToken))
+                        } else {
+                            decisionHandler(.complete())
+                        }
+                    }
+                }
+
+                do {
+                    let paymentMethodTokenJson = try paymentMethodTokenData.toJsonObject()
+                    self.sendEvent(
+                        withName: rnCallbackName,
+                        body: ["paymentMethodTokenData": paymentMethodTokenJson])
+
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+                }
+            } else {
+                if self.settings?.paymentHandling == .manual {
+                    let err = RNTNativeError(
+                        errorId: "native-ios",
+                        errorDescription: "Callback [\(rnCallbackName)] is not implemented.",
+                        recoverySuggestion: "Callback [\(rnCallbackName)] must be implemented.")
+                    self.handleRNBridgeError(err, checkoutData: nil, stopOnDebug: false)
+                }
+            }
+        }
+    }
+
+    // case onCheckoutResume
+    func primerHeadlessUniversalCheckoutDidResumeWith(_ resumeToken: String, decisionHandler: @escaping (PrimerHeadlessUniversalCheckoutResumeDecision) -> Void) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onCheckoutResume.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnCheckoutResumeImplemented == true {
+                self.primerDidResumeWithDecisionHandler = { (resumeToken, errorMessage) in
+                    DispatchQueue.main.async {
+                        if let resumeToken = resumeToken {
+                            decisionHandler(.continueWithNewClientToken(resumeToken))
+                        } else {
+                            decisionHandler(.complete())
+                        }
+                    }
+                }
+
+                self.sendEvent(
+                    withName: rnCallbackName,
+                    body: ["resumeToken": resumeToken])
+
+            } else {
+                if self.settings?.paymentHandling == .manual {
+                    let err = RNTNativeError(
+                        errorId: "native-ios",
+                        errorDescription: "Callback [\(rnCallbackName)] is not implemented.",
+                        recoverySuggestion: "Callback [\(rnCallbackName)] must be implemented.")
+                    self.handleRNBridgeError(err, checkoutData: nil, stopOnDebug: false)
+                }
+            }
+        }
+    }
+
+    // case onCheckoutPending
+    func primerHeadlessUniversalCheckoutDidEnterResumePendingWithPaymentAdditionalInfo(_ additionalInfo: PrimerCheckoutAdditionalInfo?) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onCheckoutPending.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnCheckoutPendingImplemented == true {
+                do {
+                    let checkoutAdditionalInfoJson = try additionalInfo?.toJsonObject()
+                    self.sendEvent(withName: rnCallbackName, body: checkoutAdditionalInfoJson)
+                } catch {
+                    let checkoutData = PrimerCheckoutData(payment: nil, additionalInfo: additionalInfo)
+                    self.handleRNBridgeError(error, checkoutData: checkoutData, stopOnDebug: true)
+                }
+            } else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Callback [\(rnCallbackName)] is not implemented.",
+                    recoverySuggestion: "Callback [\(rnCallbackName)] must be implemented.")
+
+                let checkoutData = PrimerCheckoutData(payment: nil, additionalInfo: additionalInfo)
+                self.handleRNBridgeError(err, checkoutData: checkoutData, stopOnDebug: false)
+            }
+        }
+    }
+
+    // case onCheckoutAdditionalInfo
+    func primerHeadlessUniversalCheckoutDidReceiveAdditionalInfo(_ additionalInfo: PrimerCheckoutAdditionalInfo?) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onCheckoutAdditionalInfo.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnCheckoutAdditionalInfoImplemented == true {
+                do {
+                    let checkoutAdditionalInfoJson = try additionalInfo?.toJsonObject()
+                    self.sendEvent(
+                        withName: rnCallbackName,
+                        body: checkoutAdditionalInfoJson)
+
+                } catch {
+                    let checkoutData = PrimerCheckoutData(payment: nil, additionalInfo: additionalInfo)
+                    self.handleRNBridgeError(error, checkoutData: checkoutData, stopOnDebug: true)
+                }
+            } else {
+                let err = RNTNativeError(
+                    errorId: "native-bridge",
+                    errorDescription: "Callback [\(rnCallbackName)] is not implemented.",
+                    recoverySuggestion: "Callback [\(rnCallbackName)] should be implemented.")
+
+                let checkoutData = PrimerCheckoutData(payment: nil, additionalInfo: additionalInfo)
+                self.handleRNBridgeError(err, checkoutData: checkoutData, stopOnDebug: false)
+            }
+        }
+    }
+
+    // case onError
+    func primerHeadlessUniversalCheckoutDidFail(withError err: Error, checkoutData: PrimerCheckoutData?) {
+        if self.implementedRNCallbacks?.isOnErrorImplemented == true {
+            // Send the error message to the RN bridge.
+            self.handleRNBridgeError(err, checkoutData: checkoutData, stopOnDebug: false)
+
+        } else {
+            // RN dev hasn't opted in on listening SDK errors.
+            // Ignore!
+        }
+    }
+
+    // case onCheckoutComplete
+    func primerHeadlessUniversalCheckoutDidCompleteCheckoutWithData(_ data: PrimerCheckoutData) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onCheckoutComplete.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnCheckoutCompleteImplemented == true {
+                do {
+                    let checkoutJson = try data.toJsonObject()
+                    self.sendEvent(withName: rnCallbackName, body: checkoutJson)
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: data, stopOnDebug: true)
+                }
+            } else {
+                let err = RNTNativeError(
+                    errorId: "native-ios",
+                    errorDescription: "Callback [\(rnCallbackName)] is not implemented.",
+                    recoverySuggestion: "Callback [\(rnCallbackName)] must be implemented.")
+                self.handleRNBridgeError(err, checkoutData: data, stopOnDebug: false)
+            }
+        }
+    }
+
+    // case onBeforeClientSessionUpdate
+    func primerHeadlessUniversalCheckoutWillUpdateClientSession() {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onBeforeClientSessionUpdate.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnBeforeClientSessionUpdateImplemented == true {
+                self.sendEvent(
+                    withName: rnCallbackName,
+                    body: nil)
+            }
+        }
+    }
+
+    // case onClientSessionUpdate
+    func primerHeadlessUniversalCheckoutDidUpdateClientSession(_ clientSession: PrimerClientSession) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onClientSessionUpdate.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnClientSessionUpdateImplemented == true {
+                do {
+                    let json = try clientSession.toJsonObject()
+                    self.sendEvent(
+                        withName: rnCallbackName,
+                        body: ["clientSession": json])
+
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+                }
+            }
+        }
+    }
+
+    // case onBeforePaymentCreate
+    func primerHeadlessUniversalCheckoutWillCreatePaymentWithData(_ data: PrimerCheckoutPaymentMethodData, decisionHandler: @escaping (PrimerPaymentCreationDecision) -> Void) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onBeforePaymentCreate.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnBeforePaymentCreateImplemented == true {
+                self.primerWillCreatePaymentWithDataDecisionHandler = { errorMessage in
+                    DispatchQueue.main.async {
+                        if let errorMessage = errorMessage {
+                            decisionHandler(.abortPaymentCreation(withErrorMessage: errorMessage.isEmpty ? nil : errorMessage))
+                        } else {
+                            decisionHandler(.continuePaymentCreation())
+                        }
+                    }
+                }
+
+                do {
+                    let checkoutPaymentmethodJson = try data.toJsonObject()
+                    self.sendEvent(
+                        withName: rnCallbackName,
+                        body: checkoutPaymentmethodJson)
+
+                } catch {
+                    self.handleRNBridgeError(error, checkoutData: nil, stopOnDebug: true)
+                }
+
+            } else {
+                // 'primerHeadlessUniversalCheckoutWillCreatePaymentWithData' hasn't
+                // been implemented on the RN side, continue the payment flow.
+                decisionHandler(.continuePaymentCreation())
+            }
+        }
+    }
+
+}
+
+extension RNTPrimerHeadlessUniversalCheckout: PrimerHeadlessUniversalCheckoutUIDelegate {
+
+    // onPreparationStart
+    func primerHeadlessUniversalCheckoutUIDidStartPreparation(for paymentMethodType: String) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onPreparationStart.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnPreparationStartImplemented == true {
+                self.sendEvent(
+                    withName: rnCallbackName,
+                    body: ["paymentMethodType": paymentMethodType])
+            }
+        }
+    }
+
+    func primerHeadlessUniversalCheckoutUIDidShowPaymentMethod(for paymentMethodType: String) {
+        let rnCallbackName = PrimerHeadlessUniversalCheckoutEvents.onPaymentMethodShow.stringValue
+
+        DispatchQueue.main.async {
+            if self.implementedRNCallbacks?.isOnPaymentMethodShowImplemented == true {
+                self.sendEvent(
+                    withName: rnCallbackName,
+                    body: ["paymentMethodType": paymentMethodType])
+            }
+        }
+    }
+}

package/ios/Sources/Helpers/Encodable+Extension.swift

@@ -0,0 +1,17 @@
+//
+//  Encodable+Extension.swift
+//  primer-io-react-native
+//
+//  Created by Evangelos on 7/10/22.
+//
+
+import Foundation
+
+extension Encodable {
+    
+    func toJsonObject() throws -> Any {
+        let data = try JSONEncoder().encode(self)
+        let json = try JSONSerialization.jsonObject(with: data, options: .allowFragments)
+        return json
+    }
+}