@primer-io/react-native 2.29.0 → 2.30.1

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNPrimerHeadlessUniversalCheckoutVaultManager.swift

@@ -1,85 +1,107 @@
 import PrimerSDK
 
+// swiftlint:disable type_name
 @objc(RNPrimerHeadlessUniversalCheckoutVaultManager)
 class RNPrimerHeadlessUniversalCheckoutVaultManager: RCTEventEmitter {
+  // swiftlint:enable type_name
 
-    private var vaultedManager: PrimerHeadlessUniversalCheckout.VaultManager!
+  private var vaultedManager: PrimerHeadlessUniversalCheckout.VaultManager!
 
-    override func supportedEvents() -> [String]! {
-        return []
-    }
+  override func supportedEvents() -> [String]! {
+    return []
+  }
+
+  override class func requiresMainQueueSetup() -> Bool {
+    return true
+  }
 
-    override class func requiresMainQueueSetup() -> Bool {
-        return true
+  @objc
+  func configure(
+    _ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      self.vaultedManager = PrimerSDK.PrimerHeadlessUniversalCheckout.VaultManager()
+      try self.vaultedManager.configure()
+      resolver(nil)
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
+  }
 
-    @objc
-    func configure(_ resolver : @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+  @objc
+  func fetchVaultedPaymentMethods(
+    _ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    self.vaultedManager.fetchVaultedPaymentMethods { vaultedPaymentMethods, err in
+      if let err = err {
+        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+      } else if let paymentMethods = vaultedPaymentMethods {
         do {
-            self.vaultedManager = PrimerSDK.PrimerHeadlessUniversalCheckout.VaultManager()
-            try self.vaultedManager.configure()
-            resolver(nil)
+          let paymentMethodObjects = try paymentMethods.compactMap({ try $0.toJsonObject() })
+          resolver(["paymentMethods": paymentMethodObjects])
         } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+          rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
         }
+      }
     }
+  }
 
-    @objc
-    func fetchVaultedPaymentMethods(_ resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        self.vaultedManager.fetchVaultedPaymentMethods { vaultedPaymentMethods, err in
-            if let err = err {
-                rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
-            } else if let paymentMethods = vaultedPaymentMethods {
-                do {
-                    let paymentMethodObjects = try paymentMethods.compactMap({ try $0.toJsonObject() })
-                    resolver(["paymentMethods": paymentMethodObjects])
-                } catch {
-                    rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-                }
-            }
-        }
+  @objc
+  func deleteVaultedPaymentMethod(
+    _ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    self.vaultedManager.deleteVaultedPaymentMethod(id: vaultedPaymentMethodId) { err in
+      if let err = err {
+        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+      } else {
+        resolver([])
+      }
     }
-    
-    @objc
-    func deleteVaultedPaymentMethod(_ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        self.vaultedManager.deleteVaultedPaymentMethod(id: vaultedPaymentMethodId) { err in
-            if let err = err {
-                rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
-            } else {
-                resolver([])
-            }
-        }
-    }
-    
-    @objc
-    func validate(_ vaultedPaymentMethodId: String, additionalDataStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        do {
-            let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
-            self.vaultedManager.validate(vaultedPaymentMethodId: vaultedPaymentMethodId, vaultedPaymentMethodAdditionalData: additionalData) { err in
-                if let err = err, err.count > 0 {
-                    rejecter(err.first!.rnError["errorId"]!, err.first!.rnError["description"], err.first!)
-                } else {
-                    resolver(["validationErrors": []])
-                }
-            }
-        } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+  }
+
+  @objc
+  func validate(
+    _ vaultedPaymentMethodId: String, additionalDataStr: String,
+    resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
+      self.vaultedManager.validate(
+        vaultedPaymentMethodId: vaultedPaymentMethodId,
+        vaultedPaymentMethodAdditionalData: additionalData
+      ) { err in
+        if let err = err, err.count > 0 {
+          rejecter(err.first!.rnError["errorId"]!, err.first!.rnError["description"], err.first!)
+        } else {
+          resolver(["validationErrors": []])
         }
+      }
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
-    
-    @objc
-    func startPaymentFlow(_ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        self.vaultedManager.startPaymentFlow(vaultedPaymentMethodId: vaultedPaymentMethodId)
-    }
-    
-    @objc
-    func startPaymentFlowWithAdditionalData(_ vaultedPaymentMethodId: String, additionalDataStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        do {
-            let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
-            self.vaultedManager.startPaymentFlow(vaultedPaymentMethodId: vaultedPaymentMethodId,
-                                                 vaultedPaymentMethodAdditionalData: additionalData)
-        } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-        }
+  }
+
+  @objc
+  func startPaymentFlow(
+    _ vaultedPaymentMethodId: String, resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    self.vaultedManager.startPaymentFlow(vaultedPaymentMethodId: vaultedPaymentMethodId)
+  }
+
+  @objc
+  func startPaymentFlowWithAdditionalData(
+    _ vaultedPaymentMethodId: String, additionalDataStr: String,
+    resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      let additionalData = try PrimerVaultedCardAdditionalData.from(jsonString: additionalDataStr)
+      self.vaultedManager.startPaymentFlow(
+        vaultedPaymentMethodId: vaultedPaymentMethodId,
+        vaultedPaymentMethodAdditionalData: additionalData)
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
+  }
 }

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNTNativeUIManager.swift

@@ -8,56 +8,64 @@
 import Foundation
 import PrimerSDK
 
+// swiftlint:disable type_name
 @objc(RNTPrimerHeadlessUniversalPaymentMethodNativeUIManager)
 class RNTPrimerHeadlessUniversalPaymentMethodNativeUIManager: RCTEventEmitter {
+  // swiftlint:enable type_name
 
-    var paymentMethodNativeUIManager: PrimerSDK.PrimerHeadlessUniversalCheckout.NativeUIManager!
+  var paymentMethodNativeUIManager: PrimerSDK.PrimerHeadlessUniversalCheckout.NativeUIManager!
 
-    override func supportedEvents() -> [String]! {
-        return []
-    }
+  override func supportedEvents() -> [String]! {
+    return []
+  }
 
-    override class func requiresMainQueueSetup() -> Bool {
-        return true
-    }
+  override class func requiresMainQueueSetup() -> Bool {
+    return true
+  }
 
-    @objc
-    func configure(
-        _ paymentMethod: String,
-        resolver: @escaping RCTPromiseResolveBlock,
-        rejecter: @escaping RCTPromiseRejectBlock
-    ) {
-        do {
-            self.paymentMethodNativeUIManager = try PrimerSDK.PrimerHeadlessUniversalCheckout.NativeUIManager(paymentMethodType: paymentMethod)
-            resolver(nil)
-        } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-        }
+  @objc
+  func configure(
+    _ paymentMethod: String,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      self.paymentMethodNativeUIManager = try PrimerSDK.PrimerHeadlessUniversalCheckout
+        .NativeUIManager(paymentMethodType: paymentMethod)
+      resolver(nil)
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
+  }
+
+  @objc
+  func showPaymentMethod(
+    _ intentStr: String, resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      guard let paymentMethodNativeUIManager = paymentMethodNativeUIManager else {
+        let err = RNTNativeError(
+          errorId: "native-ios",
+          errorDescription: "The NativeUIManager has not been initialized.",
+          recoverySuggestion:
+            "Initialize the NativeUIManager by calling the initialize function and providing a payment method type."
+        )
+        throw err
+      }
+
+      guard let intent = PrimerSessionIntent(rawValue: intentStr) else {
+        let err = RNTNativeError(
+          errorId: "native-ios",
+          errorDescription: "Invalid value for 'intent'.",
+          recoverySuggestion: "'intent' can be 'CHECKOUT' or 'VAULT'.")
+        throw err
+      }
+
+      try paymentMethodNativeUIManager.showPaymentMethod(intent: intent)
 
-    @objc
-    func showPaymentMethod(_ intentStr: String, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
-        do {
-            guard let paymentMethodNativeUIManager = paymentMethodNativeUIManager else {
-                let err = RNTNativeError(
-                    errorId: "native-ios",
-                    errorDescription: "The NativeUIManager has not been initialized.",
-                    recoverySuggestion: "Initialize the NativeUIManager by calling the initialize function and providing a payment method type.")
-                throw err
-            }
-
-            guard let intent = PrimerSessionIntent(rawValue: intentStr) else {
-                let err = RNTNativeError(
-                    errorId: "native-ios",
-                    errorDescription: "Invalid value for 'intent'.",
-                    recoverySuggestion: "'intent' can be 'CHECKOUT' or 'VAULT'.")
-                throw err
-            }
-
-            try paymentMethodNativeUIManager.showPaymentMethod(intent: intent)
-
-        } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-        }
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
+  }
 }

package/ios/Sources/Headless Universal Checkout/Managers/Payment Method Managers/RNTRawDataManager.swift

@@ -8,192 +8,215 @@
 import Foundation
 import PrimerSDK
 
+// swiftlint:disable type_name
 @objc
 enum PrimerHeadlessUniversalCheckoutRawDataManagerEvents: Int, CaseIterable {
+  // swiftlint:enable type_name
 
-    case onMetadataChange = 0
-    case onValidation
+  case onMetadataChange = 0
+  case onValidation
 
-    var stringValue: String {
-        switch self {
-        case .onMetadataChange:
-            return "onMetadataChange"
-        case .onValidation:
-            return "onValidation"
-        }
+  var stringValue: String {
+    switch self {
+    case .onMetadataChange:
+      return "onMetadataChange"
+    case .onValidation:
+      return "onValidation"
     }
+  }
 }
 
+// swiftlint:disable type_name
 @objc(RNTPrimerHeadlessUniversalCheckoutRawDataManager)
 class RNTPrimerHeadlessUniversalCheckoutRawDataManager: RCTEventEmitter {
-
-    private var rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager!
-    private var paymentMethodType: String?
-
-    override class func requiresMainQueueSetup() -> Bool {
-        return true
-    }
-
-    override func supportedEvents() -> [String]! {
-        return PrimerHeadlessUniversalCheckoutRawDataManagerEvents.allCases.compactMap({ $0.stringValue })
+  // swiftlint:enable type_name
+
+  private var rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager!
+  private var paymentMethodType: String?
+
+  override class func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  override func supportedEvents() -> [String]! {
+    return PrimerHeadlessUniversalCheckoutRawDataManagerEvents.allCases.compactMap({
+      $0.stringValue
+    })
+  }
+
+  // MARK: - API
+
+  @objc
+  public func configure(
+    _ paymentMethodTypeStr: String,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    self.paymentMethodType = paymentMethodTypeStr
+
+    do {
+      self.rawDataManager = try PrimerHeadlessUniversalCheckout.RawDataManager(
+        paymentMethodType: self.paymentMethodType!, delegate: self)
+    } catch {
+      rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
     }
 
-    // MARK: - API
-
-    @objc
-    public func configure(
-        _ paymentMethodTypeStr: String,
-        resolver: @escaping RCTPromiseResolveBlock,
-        rejecter: @escaping RCTPromiseRejectBlock
-    ) {
-        self.paymentMethodType = paymentMethodTypeStr
-
-        do {
-            self.rawDataManager = try PrimerHeadlessUniversalCheckout.RawDataManager(paymentMethodType: self.paymentMethodType!, delegate: self)
-        } catch {
-            rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-        }
-
-        self.rawDataManager!.configure { data, error in
-            do {
-                guard error == nil else {
-                    rejecter(error!.rnError["errorId"]!, error!.rnError["description"], error)
-                    return
-                }
-                let initializationData = try JSONEncoder().encode(data)
-                let initializationDataJson = try JSONSerialization.jsonObject(with: initializationData, options: .allowFragments)
-                resolver(["initializationData": initializationDataJson])
-            } catch {
-                rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
-            }
+    self.rawDataManager!.configure { data, error in
+      do {
+        guard error == nil else {
+          rejecter(error!.rnError["errorId"]!, error!.rnError["description"], error)
+          return
         }
+        let initializationData = try JSONEncoder().encode(data)
+        let initializationDataJson = try JSONSerialization.jsonObject(
+          with: initializationData, options: .allowFragments)
+        resolver(["initializationData": initializationDataJson])
+      } catch {
+        rejecter(error.rnError["errorId"]!, error.rnError["description"], error)
+      }
     }
-
-    @objc
-    public func listRequiredInputElementTypes(
-        _ resolver: RCTPromiseResolveBlock,
-        rejecter: RCTPromiseRejectBlock
-    ) {
-        guard let rawDataManager = rawDataManager else {
-            let err = RNTNativeError(
-                errorId: "native-ios",
-                errorDescription: "The RawDataManager has not been initialized",
-                recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
-            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
-            return
-        }
-
-        let inputElementTypes = rawDataManager.listRequiredInputElementTypes(for: rawDataManager.paymentMethodType).compactMap({ $0.stringValue })
-        resolver(["inputElementTypes": inputElementTypes])
+  }
+
+  @objc
+  public func listRequiredInputElementTypes(
+    _ resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock
+  ) {
+    guard let rawDataManager = rawDataManager else {
+      let err = RNTNativeError(
+        errorId: "native-ios",
+        errorDescription: "The RawDataManager has not been initialized",
+        recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
+      rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+      return
     }
 
-    @objc
-    public func setRawData(
-        _ rawDataStr: String,
-        resolver: RCTPromiseResolveBlock,
-        rejecter: RCTPromiseRejectBlock
-    ) {
-        guard let rawDataManager = rawDataManager else {
-            let err = RNTNativeError(
-                errorId: "native-ios",
-                errorDescription: "The RawDataManager has not been initialized",
-                recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
-            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
-            return
-        }
-
-        if let rawCardData = PrimerCardData(cardDataStr: rawDataStr) {
-            rawDataManager.rawData = rawCardData
-            resolver(nil)
-            return
-        }
-
-        if let rawPhoneNumberData = PrimerPhoneNumberData(phoneNumbeDatarStr: rawDataStr) {
-            rawDataManager.rawData = rawPhoneNumberData
-            resolver(nil)
-            return
-        }
+    let inputElementTypes = rawDataManager.listRequiredInputElementTypes(
+      for: rawDataManager.paymentMethodType
+    ).compactMap({ $0.stringValue })
+    resolver(["inputElementTypes": inputElementTypes])
+  }
+
+  @objc
+  public func setRawData(
+    _ rawDataStr: String,
+    resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock
+  ) {
+    guard let rawDataManager = rawDataManager else {
+      let err = RNTNativeError(
+        errorId: "native-ios",
+        errorDescription: "The RawDataManager has not been initialized",
+        recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
+      rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+      return
+    }
 
-        if let rawCardRedirectData = PrimerBancontactCardData(bankcontactCardDataStr: rawDataStr) {
-            rawDataManager.rawData = rawCardRedirectData
-            resolver(nil)
-            return
-        }
+    if let rawCardData = PrimerCardData(cardDataStr: rawDataStr) {
+      rawDataManager.rawData = rawCardData
+      resolver(nil)
+      return
+    }
 
-        if let rawRetailerData = PrimerRetailerData(primerRetailerDataStr: rawDataStr) {
-            rawDataManager.rawData = rawRetailerData
-            resolver(nil)
-            return
-        }
+    if let rawPhoneNumberData = PrimerPhoneNumberData(phoneNumbeDatarStr: rawDataStr) {
+      rawDataManager.rawData = rawPhoneNumberData
+      resolver(nil)
+      return
+    }
 
-        let err = RNTNativeError(
-            errorId: "native-ios",
-            errorDescription: "Failed to decode RawData on iOS.",
-            recoverySuggestion: "Make sure you're providing a valid 'RawData' (or any inherited) object.")
-        rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+    if let rawCardRedirectData = PrimerBancontactCardData(bankcontactCardDataStr: rawDataStr) {
+      rawDataManager.rawData = rawCardRedirectData
+      resolver(nil)
+      return
     }
 
-    @objc
-    public func submit(
-        _ resolver: RCTPromiseResolveBlock,
-        rejecter: RCTPromiseRejectBlock
-    ) {
-        guard let rawDataManager = rawDataManager else {
-            let err = RNTNativeError(
-                errorId: "native-ios",
-                errorDescription: "The RawDataManager has not been initialized",
-                recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
-            rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
-            return
-        }
+    if let rawRetailerData = PrimerRetailerData(primerRetailerDataStr: rawDataStr) {
+      rawDataManager.rawData = rawRetailerData
+      resolver(nil)
+      return
+    }
 
-        rawDataManager.submit()
-        resolver(nil)
+    let err = RNTNativeError(
+      errorId: "native-ios",
+      errorDescription: "Failed to decode RawData on iOS.",
+      recoverySuggestion: "Make sure you're providing a valid 'RawData' (or any inherited) object.")
+    rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+  }
+
+  @objc
+  public func submit(
+    _ resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock
+  ) {
+    guard let rawDataManager = rawDataManager else {
+      let err = RNTNativeError(
+        errorId: "native-ios",
+        errorDescription: "The RawDataManager has not been initialized",
+        recoverySuggestion: "Make sure you have called initialized the `RawDataManager' first.")
+      rejecter(err.rnError["errorId"]!, err.rnError["description"], err)
+      return
     }
 
-    @objc
-    public func cleanUp(
-        _ resolver: RCTPromiseResolveBlock,
-        rejecter: RCTPromiseRejectBlock
-    ) {
+    rawDataManager.submit()
+    resolver(nil)
+  }
 
-    }
+  @objc
+  public func cleanUp(
+    _ resolver: RCTPromiseResolveBlock,
+    rejecter: RCTPromiseRejectBlock
+  ) {
 
-}
+  }
 
-extension RNTPrimerHeadlessUniversalCheckoutRawDataManager: PrimerHeadlessUniversalCheckoutRawDataManagerDelegate {
+}
 
-    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager, metadataDidChange metadata: [String : Any]?) {
-        DispatchQueue.main.async {
-            self.sendEvent(withName: PrimerHeadlessUniversalCheckoutRawDataManagerEvents.onMetadataChange.stringValue, body: metadata)
-        }
+extension RNTPrimerHeadlessUniversalCheckoutRawDataManager:
+  PrimerHeadlessUniversalCheckoutRawDataManagerDelegate {
+
+  func primerRawDataManager(
+    _ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager,
+    metadataDidChange metadata: [String: Any]?
+  ) {
+    DispatchQueue.main.async {
+      self.sendEvent(
+        withName: PrimerHeadlessUniversalCheckoutRawDataManagerEvents.onMetadataChange.stringValue,
+        body: metadata)
     }
-
-    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager, dataIsValid isValid: Bool, errors: [Error]?) {
-        DispatchQueue.main.async {
-            var body: [String: Any] = ["isValid": isValid]
-            if let errors = errors {
-                let rnErrors = errors.compactMap({ $0.rnError })
-                body["errors"] = rnErrors
-            }
-            self.sendEvent(withName: PrimerHeadlessUniversalCheckoutRawDataManagerEvents.onValidation.stringValue, body: body)
-        }
+  }
+
+  func primerRawDataManager(
+    _ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager, dataIsValid isValid: Bool,
+    errors: [Error]?
+  ) {
+    DispatchQueue.main.async {
+      var body: [String: Any] = ["isValid": isValid]
+      if let errors = errors {
+        let rnErrors = errors.compactMap({ $0.rnError })
+        body["errors"] = rnErrors
+      }
+      self.sendEvent(
+        withName: PrimerHeadlessUniversalCheckoutRawDataManagerEvents.onValidation.stringValue,
+        body: body)
     }
-
-    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
-            }
-            print(body)
-            self.sendEvent(withName: PrimerEvents.onError.stringValue, body: body)
-        }
+  }
+
+  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
+      }
+      print(body)
+      self.sendEvent(withName: PrimerEvents.onError.stringValue, body: body)
     }
+  }
 }