@yuno-payments/yuno-sdk-react-native 1.0.16

package/android/src/main/java/com/yunosdkreactnative/YunoSdkPackage.kt

@@ -0,0 +1,24 @@
+package com.yunosdkreactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * Yuno SDK React Native Package.
+ * 
+ * This class registers the Yuno SDK module with React Native.
+ */
+class YunoSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(YunoSdkModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(
+            YunoPaymentMethodsViewManager(reactContext)
+        )
+    }
+}
+

package/ios/YunoSdk.m

@@ -0,0 +1,65 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(YunoSdk, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(
+    initialize:(NSString *)apiKey
+    countryCode:(NSString *)countryCode
+    yunoConfig:(NSDictionary *)yunoConfig
+    iosConfig:(NSDictionary *)iosConfig
+    androidConfig:(NSDictionary *)androidConfig
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    enrollmentPayment:(NSDictionary *)arguments
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    startPaymentLite:(NSDictionary *)arguments
+    countryCode:(NSString *)countryCode
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    startPayment:(BOOL)showPaymentStatus
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    continuePayment:(BOOL)showPaymentStatus
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    startPaymentSeamlessLite:(NSDictionary *)arguments
+    language:(NSString *)language
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    hideLoader:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
+RCT_EXTERN_METHOD(
+    receiveDeeplink:(NSString *)url
+    resolver:(RCTPromiseResolveBlock)resolver
+    rejecter:(RCTPromiseRejectBlock)rejecter
+)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+@end
+

package/ios/YunoSdk.podspec

@@ -0,0 +1,48 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "../package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "YunoSdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "14.0" }
+  s.source       = { :git => "https://github.com/yuno-payments/yuno-sdk-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "*.{h,m,mm,swift}"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+
+  # Yuno iOS SDK
+  s.dependency "YunoSDK", "2.7.1"
+  
+  s.swift_version = '5.0'
+  s.static_framework = true
+end
+

package/ios/YunoSdk.swift

@@ -0,0 +1,442 @@
+import Foundation
+import YunoSDK
+
+/**
+ * Yuno SDK React Native Module for iOS.
+ *
+ * This module provides a bridge between React Native JavaScript code and the native Yuno iOS SDK.
+ */
+@objc(YunoSdk)
+class YunoSdk: RCTEventEmitter {
+    
+    private var isInitialized = false
+    private var currentCountryCode: String?
+    private var currentLanguage: String?
+    private var customerSession: String = ""
+    private var checkoutSession: String = ""
+    
+    override init() {
+        super.init()
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return [
+            "YunoPaymentStatus",
+            "YunoEnrollmentStatus",
+            "YunoOneTimeToken"
+        ]
+    }
+    
+    /**
+     * Initialize the Yuno SDK with configuration.
+     */
+    @objc
+    func initialize(
+        _ apiKey: String,
+        countryCode: String,
+        yunoConfig: NSDictionary,
+        iosConfig: NSDictionary?,
+        androidConfig: NSDictionary?,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                self.currentCountryCode = countryCode
+                
+                // Parse language
+                if let lang = yunoConfig["lang"] as? String {
+                    self.currentLanguage = lang
+                }
+                
+                // Parse card flow
+                var cardFlow: YunoCardFlow = .oneStep
+                if let flow = yunoConfig["cardFlow"] as? String {
+                    cardFlow = self.mapToCardFlow(flow)
+                }
+                
+                // Parse other config options
+                let saveCardEnabled = yunoConfig["saveCardEnabled"] as? Bool ?? false
+                let keepLoader = yunoConfig["keepLoader"] as? Bool ?? false
+                
+                // Initialize Yuno SDK
+                Yuno.initialize(
+                    apiKey: apiKey,
+                    config: YunoConfig(
+                        cardFlow: cardFlow,
+                        saveCardEnabled: saveCardEnabled,
+                        keepLoader: keepLoader
+                    )
+                )
+                
+                self.isInitialized = true
+                resolver(nil)
+            } catch {
+                rejecter("INITIALIZATION_ERROR", "Failed to initialize Yuno SDK: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Start enrollment payment flow.
+     */
+    @objc
+    func enrollmentPayment(
+        _ arguments: NSDictionary,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard isInitialized else {
+            rejecter("NOT_INITIALIZED", "Yuno SDK is not initialized", nil)
+            return
+        }
+        
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                guard let customerSession = arguments["customerSession"] as? String, !customerSession.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "customerSession is required"])
+                }
+                
+                let showPaymentStatus = arguments["showPaymentStatus"] as? Bool ?? true
+                
+                var countryCode = arguments["countryCode"] as? String
+                if countryCode == nil || countryCode!.isEmpty {
+                    countryCode = self.currentCountryCode
+                }
+                
+                guard let safeCountryCode = countryCode, !safeCountryCode.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "countryCode is required"])
+                }
+                
+                self.customerSession = customerSession
+                self.currentCountryCode = safeCountryCode
+                
+                Yuno.enrollPayment(with: self, showPaymentStatus: showPaymentStatus)
+                
+                resolver(nil)
+            } catch {
+                rejecter("ENROLLMENT_ERROR", "Failed to start enrollment: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Start payment lite flow.
+     */
+    @objc
+    func startPaymentLite(
+        _ arguments: NSDictionary,
+        countryCode: String,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard isInitialized else {
+            rejecter("NOT_INITIALIZED", "Yuno SDK is not initialized", nil)
+            return
+        }
+        
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                guard let checkoutSession = arguments["checkoutSession"] as? String, !checkoutSession.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "checkoutSession is required"])
+                }
+                
+                guard let methodSelected = arguments["methodSelected"] as? NSDictionary else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "methodSelected is required"])
+                }
+                
+                guard let vaultedToken = methodSelected["vaultedToken"] as? String, !vaultedToken.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "vaultedToken is required"])
+                }
+                
+                guard let paymentMethodType = methodSelected["paymentMethodType"] as? String, !paymentMethodType.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "paymentMethodType is required"])
+                }
+                
+                let showPaymentStatus = arguments["showPaymentStatus"] as? Bool ?? true
+                
+                self.checkoutSession = checkoutSession
+                self.currentCountryCode = countryCode
+                
+                let paymentSelected = Yuno.PaymentSelected(
+                    paymentMethodType: paymentMethodType,
+                    vaultedToken: vaultedToken
+                )
+                
+                Yuno.startPaymentLite(
+                    with: self,
+                    paymentSelected: paymentSelected,
+                    showPaymentStatus: showPaymentStatus
+                )
+                
+                resolver(nil)
+            } catch {
+                rejecter("PAYMENT_LITE_ERROR", "Failed to start payment lite: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Start full payment flow.
+     */
+    @objc
+    func startPayment(
+        _ showPaymentStatus: Bool,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard isInitialized else {
+            rejecter("NOT_INITIALIZED", "Yuno SDK is not initialized", nil)
+            return
+        }
+        
+        DispatchQueue.main.async {
+            do {
+                Yuno.startPayment(showPaymentStatus: showPaymentStatus)
+                resolver(nil)
+            } catch {
+                rejecter("PAYMENT_ERROR", "Failed to start payment: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Continue payment flow.
+     */
+    @objc
+    func continuePayment(
+        _ showPaymentStatus: Bool,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard isInitialized else {
+            rejecter("NOT_INITIALIZED", "Yuno SDK is not initialized", nil)
+            return
+        }
+        
+        DispatchQueue.main.async {
+            do {
+                Yuno.continuePayment()
+                resolver(nil)
+            } catch {
+                rejecter("CONTINUE_PAYMENT_ERROR", "Failed to continue payment: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Start seamless payment lite flow.
+     */
+    @objc
+    func startPaymentSeamlessLite(
+        _ arguments: NSDictionary,
+        language: String,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        guard isInitialized else {
+            rejecter("NOT_INITIALIZED", "Yuno SDK is not initialized", nil)
+            return
+        }
+        
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            do {
+                guard let checkoutSession = arguments["checkoutSession"] as? String, !checkoutSession.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "checkoutSession is required"])
+                }
+                
+                guard let methodSelected = arguments["methodSelected"] as? NSDictionary else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "methodSelected is required"])
+                }
+                
+                guard let vaultedToken = methodSelected["vaultedToken"] as? String, !vaultedToken.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "vaultedToken is required"])
+                }
+                
+                guard let paymentMethodType = methodSelected["paymentMethodType"] as? String, !paymentMethodType.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "paymentMethodType is required"])
+                }
+                
+                let showPaymentStatus = arguments["showPaymentStatus"] as? Bool ?? true
+                
+                var countryCode = arguments["countryCode"] as? String
+                if countryCode == nil || countryCode!.isEmpty {
+                    countryCode = self.currentCountryCode
+                }
+                
+                guard let safeCountryCode = countryCode, !safeCountryCode.isEmpty else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "countryCode is required"])
+                }
+                
+                self.checkoutSession = checkoutSession
+                self.currentCountryCode = safeCountryCode
+                
+                let paymentSelected = Yuno.PaymentSelected(
+                    paymentMethodType: paymentMethodType,
+                    vaultedToken: vaultedToken
+                )
+                
+                Yuno.startPaymentLite(
+                    with: self,
+                    paymentSelected: paymentSelected,
+                    showPaymentStatus: showPaymentStatus
+                )
+                
+                // Return initial processing status
+                resolver("PROCESSING")
+            } catch {
+                rejecter("SEAMLESS_ERROR", "Failed to start seamless payment: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Hide loader.
+     */
+    @objc
+    func hideLoader(
+        _ resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            do {
+                Yuno.hideLoader()
+                resolver(nil)
+            } catch {
+                rejecter("HIDE_LOADER_ERROR", "Failed to hide loader: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    /**
+     * Receive deeplink for payment resumption.
+     */
+    @objc
+    func receiveDeeplink(
+        _ url: String,
+        resolver: @escaping RCTPromiseResolveBlock,
+        rejecter: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            do {
+                guard !url.isEmpty, let deeplink = URL(string: url) else {
+                    throw NSError(domain: "YunoSdk", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])
+                }
+                
+                Yuno.receiveDeeplink(deeplink)
+                resolver(nil)
+            } catch {
+                rejecter("DEEPLINK_ERROR", "Failed to process deeplink: \(error.localizedDescription)", error)
+            }
+        }
+    }
+    
+    // MARK: - Helper Methods
+    
+    private func mapToCardFlow(_ cardFlow: String) -> YunoCardFlow {
+        switch cardFlow {
+        case "STEP_BY_STEP":
+            return .multiStep
+        default:
+            return .oneStep
+        }
+    }
+    
+    private func mapStatusToString(_ status: YunoPaymentStatus) -> String {
+        switch status {
+        case .rejected:
+            return "REJECTED"
+        case .succeeded:
+            return "SUCCEEDED"
+        case .failed:
+            return "FAILED"
+        case .processing:
+            return "PROCESSING"
+        case .internalError:
+            return "INTERNAL_ERROR"
+        case .cancelledByUser:
+            return "CANCELLED_BY_USER"
+        @unknown default:
+            return "INTERNAL_ERROR"
+        }
+    }
+    
+    // MARK: - Event Emitters
+    
+    private func sendPaymentStatusEvent(status: YunoPaymentStatus, token: String? = nil) {
+        var params: [String: Any] = ["status": mapStatusToString(status)]
+        if let token = token {
+            params["token"] = token
+        }
+        sendEvent(withName: "YunoPaymentStatus", body: params)
+    }
+    
+    private func sendEnrollmentStatusEvent(status: YunoPaymentStatus) {
+        let params: [String: Any] = ["status": mapStatusToString(status)]
+        sendEvent(withName: "YunoEnrollmentStatus", body: params)
+    }
+    
+    private func sendOneTimeTokenEvent(token: String) {
+        sendEvent(withName: "YunoOneTimeToken", body: token)
+    }
+}
+
+// MARK: - YunoPaymentDelegate Extension
+extension YunoSdk: YunoPaymentDelegate {
+    func yunoCreatePayment(with token: String) {
+        sendOneTimeTokenEvent(token: token)
+    }
+    
+    func yunoPaymentResult(_ result: Yuno.Result) {
+        sendPaymentStatusEvent(status: mapResultToStatus(result))
+    }
+    
+    var countryCode: String {
+        return currentCountryCode ?? ""
+    }
+    
+    var checkoutSession: String {
+        return self.checkoutSession
+    }
+    
+    private func mapResultToStatus(_ result: Yuno.Result) -> YunoPaymentStatus {
+        switch result {
+        case .succeeded:
+            return .succeeded
+        case .failed:
+            return .failed
+        case .rejected:
+            return .rejected
+        case .processing:
+            return .processing
+        case .cancelledByUser:
+            return .cancelledByUser
+        @unknown default:
+            return .internalError
+        }
+    }
+}
+
+// MARK: - YunoEnrollmentDelegate Extension
+extension YunoSdk: YunoEnrollmentDelegate {
+    func yunoEnrollmentResult(_ result: Yuno.Result) {
+        sendEnrollmentStatusEvent(status: mapResultToStatus(result))
+    }
+    
+    var customerSession: String {
+        return self.customerSession
+    }
+}
+