@juspay-tech/react-native-hyperswitch 0.2.1

package/ios/hyperswitchSDK/Core/NativeLogger/LogManager.swift

@@ -0,0 +1,113 @@
+//
+//  HyperLogManager.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+
+final class LogManager {
+    private static var logsBatch: [LogPayload] = []
+    private static var publishableKey: String = ""
+    private static var loggingEndPoint: String?
+    private static let fileManager = LogFileManager()
+    private static let queue = DispatchQueue(label: "hyperlog.queue")
+    private static let debouncer = Debouncer(delayInMillis: 2000.0)
+    
+    private static func formatPayload(logs: [String]) -> String {
+        return "[" + logs.joined(separator: ",")
+            .replacingOccurrences(of: " ", with: "")
+            .replacingOccurrences(of: "\n", with: "") + "]"
+    }
+    
+    private static func getStringifiedLogs(_ logBatch: [LogPayload]) -> [String] {
+        return logBatch.compactMap { $0.toJson() }
+    }
+    
+    static func initialize(publishableKey: String) {
+        queue.async {
+            self.publishableKey = publishableKey
+            self.loggingEndPoint = SDKEnvironment.loggingURL(for: publishableKey)
+        }
+        if !publishableKey.isEmpty {
+            sendLogsFromFile()
+        }
+    }
+    
+    static func sendLogsFromFile() {
+        queue.async {
+            guard let endpoint = loggingEndPoint else { return }
+            let logs = fileManager.getStoredLogsInArray()
+            let payload = formatPayload(logs: logs)
+            
+            let data = payload.data(using: .utf8)
+            
+            let logRequest = HTTPRequestService(host: endpoint, path: "", endpoint: "", method: .post)
+            logRequest.headers = ["Content-Type": "application/json"]
+            logRequest.bodyData = data
+            
+            logRequest.request(type: Data.self) { (result, statusCode) in
+                switch (result, statusCode) {
+                case (.success(_), 200..<300):
+                    fileManager.clearFile()
+                default:
+                    break;
+                }
+            }
+        }
+    }
+    
+    static func saveLogsToFile() {
+        queue.async {
+            let logs = getStringifiedLogs(logsBatch)
+            fileManager.addLogs(logs: logs)
+        }
+    }
+    
+    static func saveLogsToFile(_ logsBatch: [LogPayload]) {
+        queue.async {
+            let logs = getStringifiedLogs(logsBatch)
+            fileManager.addLogs(logs: logs)
+        }
+    }
+    
+    static func addLog(_ log: LogPayload) {
+        queue.async {
+            logsBatch.append(log)
+            debouncer.debounce {
+                sendLogsOverNetwork()
+            }
+        }
+    }
+    
+    private static func sendLogsOverNetwork() {
+        queue.async {
+            guard !logsBatch.isEmpty, let endpoint = loggingEndPoint else { return }
+            var copiedLogs = logsBatch
+            logsBatch.removeAll()
+            
+            for index in copiedLogs.indices {
+                copiedLogs[index].merchant_id = LogManager.publishableKey
+            }
+            
+            let logsToSend = getStringifiedLogs(copiedLogs)
+            guard !logsToSend.isEmpty else { return }
+            
+            let payload = formatPayload(logs: logsToSend)
+            let data = payload.data(using: .utf8)
+            let logRequest = HTTPRequestService(host: endpoint, path: "", endpoint: "", method: .post)
+            
+            logRequest.headers = ["Content-Type": "application/json"]
+            logRequest.bodyData = data
+            logRequest.request(type: Data.self) { (result, statusCode) in
+                switch (result, statusCode) {
+                case (.success(_), 200..<300):
+                    break;
+                default:
+                    saveLogsToFile(copiedLogs)
+                }
+            }
+        }
+    }
+}

package/ios/hyperswitchSDK/Core/NativeModule/HyperHeadless.m

@@ -0,0 +1,16 @@
+//
+//  HyperHeadless.m
+//  Hyperswitch
+//
+//  Created by Shivam Shashank on 06/03/24.
+//
+
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(HyperHeadless, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialisePaymentSession: (RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(getPaymentSession: (NSDictionary)rnMessage :(NSDictionary)rnMessage2 :(NSArray)rnMessage3 :(RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(exitHeadless: (NSString)rnMessage)
+
+@end

package/ios/hyperswitchSDK/Core/NativeModule/HyperHeadless.swift

@@ -0,0 +1,74 @@
+//
+//  HyperHeadless.swift
+//  Hyperswitch
+//
+//  Created by Shivam Shashank on 06/03/24.
+//
+
+import Foundation
+import React
+import WebKit
+
+
+@objc(HyperHeadless)
+internal class HyperHeadless: RCTEventEmitter {
+    
+    internal static var shared:HyperHeadless?
+    
+    private var setNativeProps: RCTResponseSenderBlock?
+    private var confirmWithDefault: RCTResponseSenderBlock?
+    private var defaultPMData: ((NSDictionary?) -> Void)?
+    
+    internal override init() {
+        super.init()
+        HyperHeadless.shared = self
+    }
+    
+    @objc
+    internal override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    @objc 
+    internal override func supportedEvents() -> [String] {
+        return ["test"]
+    }
+    
+    @objc 
+    private func confirm(data: [String: Any]) {
+        self.sendEvent(withName: "test", body: data)
+    }
+    
+    @objc
+    private func sendMessageToNative(_ rnMessage: String) {}
+    
+    @objc
+    private func initialisePaymentSession (_ rnCallback: @escaping RCTResponseSenderBlock) {
+        DispatchQueue.main.async {
+            if PaymentSession.headlessCompletion != nil, !PaymentSession.isPresented {
+                let hyperParams = HyperParams.getHyperParams()
+                
+                let props: [String: Any] = [
+                    "clientSecret": PaymentSession.paymentIntentClientSecret as Any,
+                    "publishableKey": APIClient.shared.publishableKey as Any,
+                    "hyperParams": hyperParams,
+                    "customBackendUrl": APIClient.shared.customBackendUrl as Any,
+                    "customLogUrl": APIClient.shared.customLogUrl as Any,
+                    "customParams": APIClient.shared.customParams as Any
+                ]
+                rnCallback([props])
+            }
+        }
+    }
+    
+    @objc
+    private func getPaymentSession(_ rnMessage: NSDictionary, _ rnMessage2: NSDictionary, _ rnMessage3: NSArray, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        PaymentSession.getPaymentSession(getPaymentMethodData: rnMessage, getPaymentMethodData2: rnMessage2, getPaymentMethodDataArray: rnMessage3, callback: rnCallback)
+    }
+    
+    @objc
+    private func exitHeadless(_ rnMessage: String) {
+        PaymentSession.exitHeadless(rnMessage: rnMessage)
+    }
+    
+}

package/ios/hyperswitchSDK/Core/NativeModule/HyperModule.m

@@ -0,0 +1,28 @@
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(HyperModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(sendMessageToNative: (NSString)rnMessage)
+RCT_EXTERN_METHOD(presentPaymentSheet: (NSDictionary) rnMessage :(RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(exitPaymentsheet: (nonnull NSNumber *)reactTag :(NSString)rnMessage :(BOOL)reset)
+RCT_EXTERN_METHOD(exitPaymentMethodManagement: (nonnull NSNumber *)reactTag :(NSString)rnMessage :(BOOL)reset)
+RCT_EXTERN_METHOD(exitCardForm: (NSString)rnMessage)
+RCT_EXTERN_METHOD(launchWidgetPaymentSheet: (NSDictionary) rnMessage :(RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(onAddPaymentMethod: (NSString)rnMessage)
+RCT_EXTERN_METHOD(exitWidgetPaymentsheet: (nonnull NSNumber *)reactTag :(NSString)rnMessage :(BOOL)reset)
+RCT_EXTERN_METHOD(launchApplePay: (NSString)rnMessage :(RCTResponseSenderBlock)rnCallback)
+RCT_EXTERN_METHOD(startApplePay: (NSString)rnMessage :(RCTResponseSenderBlock)startCallback)
+RCT_EXTERN_METHOD(presentApplePay: (NSString)rnMessage :(RCTResponseSenderBlock)presentCallback)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+    return dispatch_get_main_queue();
+}
+
+@end
+

package/ios/hyperswitchSDK/Core/NativeModule/HyperModule.swift

@@ -0,0 +1,168 @@
+//
+//  HyperModule.swift
+//  Hyperswitch
+//
+//  Created by Harshit Srivastava on 07/03/24.
+//
+
+import Foundation
+import React
+
+@objc(HyperModule)
+internal class HyperModule: RCTEventEmitter {
+    
+    private let applePayPaymentHandler = ApplePayHandler()
+    //    private let expressCheckoutHandler = ExpressCheckoutLauncher()
+    private var presentCallback: RCTResponseSenderBlock? = nil
+    internal static var shared:HyperModule?
+    
+    override init() {
+        super.init()
+        HyperModule.shared = self
+    }
+    
+    @objc
+    internal override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+    
+    @objc 
+    internal override func supportedEvents() -> [String] {
+        return ["confirm", "confirmEC"]
+    }
+    
+    @objc 
+    internal func confirm(data: [String: Any]) {
+        self.sendEvent(withName: "confirm", body: data)
+    }
+    // MARK: WIP
+    //    @objc func confirmEC(data: [String: Any]) {
+    //        self.sendEvent(withName: "confirmEC", body: data)
+    //    }
+    
+    @objc
+    private func sendMessageToNative(_ rnMessage: String) {}
+    
+    //React Native Wrapper Function
+    @objc
+    private func presentPaymentSheet(_ request: NSMutableDictionary, _ callBack: @escaping RCTResponseSenderBlock) -> Void {
+        DispatchQueue.main.async {
+            let paymentSheet = PaymentSheet(paymentIntentClientSecret: "", configuration: PaymentSheet.Configuration())
+            paymentSheet.presentWithParams(
+                from: (UIApplication.shared.delegate?.window??.rootViewController)!,
+                props: request as! [String : Any],
+                completion: { result2 in
+                    switch result2 {
+                    case .completed(let data):
+                        callBack([["status": "completed", "message": data]])
+                    case .failed(let error as NSError):
+                        callBack([["status": "failed", "code": error.domain, "message": "Payment failed: \(error.userInfo["message"] ?? "Failed")"]])
+                    case .canceled(let data):
+                        callBack([["status": "cancelled", "message": data]])
+                    }
+                }
+            )
+        }
+    }
+    
+    //    @objc
+    //    private func launchWidgetPaymentSheet(_ request: NSMutableDictionary, _ callback: @escaping RCTResponseSenderBlock) -> Void {
+    //        expressCheckoutHandler.launchPaymentSheet(paymentResult: request,callBack: callback)
+    //    }
+    
+    //    @objc
+    //    private func onAddPaymentMethod(_ rnMessage: String) -> Void {
+    //        PaymentMethodManagementWidget.onAddPaymentMethod?()
+    //    }
+    
+    @objc
+    private func launchApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        applePayPaymentHandler.startPayment(rnMessage: rnMessage, rnCallback: rnCallback, presentCallback: self.presentCallback)
+    }
+    
+    @objc
+    private func startApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        rnCallback([])
+    }
+    
+    @objc
+    private func presentApplePay (_ rnMessage: String, _ rnCallback: @escaping RCTResponseSenderBlock) {
+        self.presentCallback = rnCallback
+    }
+    
+    //    @objc
+    //    private func exitPaymentsheet(_ reactTag: NSNumber, _ rnMessage: String, _ reset: Bool) {
+    //        exitSheet(rnMessage)
+    //    }
+    //    
+    //    @objc
+    //    private func exitWidgetPaymentsheet(_ reactTag: NSNumber, _ rnMessage: String, _ reset: Bool) {
+    //        exitSheet(rnMessage)
+    //    }
+    //    
+    //    @objc
+    //    private func exitPaymentMethodManagement(_ reactTag: NSNumber, _ rnMessage: String, _ reset: Bool) {
+    //        exitSheet(rnMessage)
+    //    }
+    //    
+    //    @objc
+    //    private func exitCardForm(_ rnMessage: String) {
+    //        var response: String?
+    //        var error: NSError?
+    //        
+    //        if let data = rnMessage.data(using: .utf8) {
+    //            do {
+    //                if let jsonDictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+    //                    let status = jsonDictionary["status"]
+    //                    
+    //                    if (status == "failed" || status == "requires_payment_method") {
+    //                        error = NSError(domain: (jsonDictionary["code"] ?? "") != "" ? jsonDictionary["code"]! : "UNKNOWN_ERROR", code: 0, userInfo: ["message" : jsonDictionary["message"] ?? "An error has occurred."])
+    //                    } else {
+    //                        response = status
+    //                    }
+    //                    RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: response, error: error)
+    //                } else {
+    //                    RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //                }
+    //            } catch {
+    //                RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //            }
+    //        } else {
+    //            RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //        }
+    //    }
+    //    
+    //    @objc
+    //    private func exitSheet(_ rnMessage: String) {
+    //        var response: String?
+    //        var error: NSError?
+    //        
+    //        if let data = rnMessage.data(using: .utf8) {
+    //            do {
+    //                if let jsonDictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: String] {
+    //                    let status = jsonDictionary["status"]
+    //                    
+    //                    if (status == "failed" || status == "requires_payment_method") {
+    //                        error = NSError(domain: (jsonDictionary["code"] ?? "") != "" ? jsonDictionary["code"]! : "UNKNOWN_ERROR", code: 0, userInfo: ["message" : jsonDictionary["message"] ?? "An error has occurred."])
+    //                    } else {
+    //                        response = status
+    //                    }
+    //                    RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: response, error: error)
+    //                } else {
+    //                    RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //                }
+    //            } catch {
+    //                RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //            }
+    //        } else {
+    //            RNViewManager.sharedInstance.responseHandler?.didReceiveResponse(response: "failed", error: NSError(domain: "UNKNOWN_ERROR", code: 0, userInfo: ["message" : "An error has occurred."]))
+    //        }
+    //        DispatchQueue.main.async {
+    //            if let view = RNViewManager.sharedInstance.rootView {
+    //                let reactNativeVC: UIViewController? = view.reactViewController()
+    //                reactNativeVC?.dismiss(animated: false, completion: nil)
+    //            }
+    //        }
+    //    }
+}
+

package/ios/hyperswitchSDK/Core/NativeModule/OTAServices.swift

@@ -0,0 +1,113 @@
+//
+//  OTAServices.swift
+//  hyperswitch
+//
+//  Created by Kuntimaddi Manideep on 24/01/25.
+//
+
+import Foundation
+import HyperOTA
+
+private func getHyperOTAPlist(_ key: String) -> String? {
+    guard let path = Bundle(for: RNFabricManager.self).path(forResource: "HyperOTA", ofType: "plist"),
+          let dict = NSDictionary(contentsOfFile: path),
+          let value = dict[key] as? String, !value.isEmpty else {
+        return nil
+    }
+    return value
+}
+
+internal class EventLogger: NSObject, HPJPLoggerDelegate {
+    private func isJSONSerializable(_ value: Any) -> Bool {
+        return JSONSerialization.isValidJSONObject(["key": value])
+    }
+    internal func addLog(eventData: [String: Any], logLevel : String, key: String?){
+        do {
+            let jsonData = try JSONSerialization.data(withJSONObject: eventData, options: [])
+            guard let jsonString = String(data: jsonData, encoding: .utf8) else {
+                print("Error: JSON data encoding failed.")
+                return
+            }
+            var log = LogBuilder()
+                .setLogType(logLevel)
+                .setValue(jsonString)
+            
+            switch key {
+            case "init_with_local_config_versions":
+                log = log.setEventName(.HYPER_OTA_INIT)
+                break
+            case "init":
+                log = log.setEventName(.HYPER_OTA_INIT)
+                break
+            case "update_end":
+                log = log.setEventName(.HYPER_OTA_FINISH)
+            case "end":
+                log = log.setEventName(.HYPER_OTA_FINISH)
+                break
+            default:
+                log = log.setEventName(.HYPER_OTA_EVENT)
+            }
+            LogManager.addLog(log.build())
+            
+        } catch {
+            print("Error serializing event data: \(error.localizedDescription)")
+        }
+    }
+    func trackEvent(
+        withLevel logLevel: String,
+        label eventLabel: String,
+        key eventKey: String? = nil,
+        value eventValue: Any,
+        category eventCategory: String,
+        subcategory eventSubcategory: String
+    ) {
+        let eventData: [String: Any] = [
+            "label": eventLabel,
+            "value": isJSONSerializable(eventValue) ? eventValue : String(describing: eventValue),
+            "key" : eventKey ?? "",
+            "category": eventCategory,
+            "subcategory": eventSubcategory
+        ]
+        addLog(eventData: eventData, logLevel: logLevel, key : eventKey)
+    }
+    func trackEvent(
+        withLevel logLevel: String,
+        label eventLabel: String,
+        value eventValue: Any,
+        category eventCategory: String,
+        subcategory eventSubcategory: String
+    ) {
+        let eventData: [String: Any] = [
+            "label": eventLabel,
+            "value": isJSONSerializable(eventValue) ? eventValue : String(describing: eventValue),
+            "category": eventCategory,
+            "subcategory": eventSubcategory
+        ]
+        addLog(eventData: eventData, logLevel: logLevel, key : eventLabel)
+        
+    }
+}
+
+public final class OTAServices {
+    public static var shared = OTAServices()
+    public var otaServices : HyperOTAServices? = nil
+    let logger = EventLogger()
+    public func initialize(publishableKey : String) {
+        if(self.otaServices == nil) {
+            let environment = SDKEnvironment.getEnvironment(publishableKey)
+            let configKey = (environment == .SANDBOX) ? "sandBoxReleaseConfigURL" : "releaseConfigURL"
+            let payload = [
+                "clientId": getHyperOTAPlist("clientId") ?? "" ,
+                "namespace": getHyperOTAPlist("namespace") ?? "",
+                "forceUpdate": true,
+                "localAssets": (getHyperOTAPlist(configKey) ?? "releaseConfigURL") == "releaseConfigURL",
+                "fileName": getHyperOTAPlist("fileName") ?? "" ,
+                "releaseConfigURL": (getHyperOTAPlist(configKey) ?? "") +  "/mobile-ota/ios/" + SDKVersion.current + "/config.json",
+            ] as [String: Any]
+            self.otaServices = HyperOTAServices(payload: payload, loggerDelegate: logger, baseBundle: Bundle(for: OTAServices.self))
+        }
+    }
+    public  func getBundleURL() -> URL? {
+        return otaServices?.bundleURL() ?? Bundle(for: OTAServices.self).url(forResource: "hyperswitch", withExtension: "bundle")
+    }
+}

package/ios/hyperswitchSDK/Core/NativeModule/RNHeadlessManager.swift

@@ -0,0 +1,45 @@
+//
+//  RNHeadlessManager.swift
+//  Hyperswitch
+//
+//  Created by Shivam Shashank on 09/11/22.
+//
+
+import Foundation
+import React
+
+//internal class RNHeadlessManager: NSObject {
+//    internal var responseHandler: RNResponseHandler?
+//    internal var rootView: RCTRootView?
+//    
+//    internal lazy var bridgeHeadless: RCTBridge = {
+//        RCTBridge.init(delegate: self, launchOptions: nil)
+//    }()
+//    
+//    internal static let sharedInstance = RNHeadlessManager()
+//    
+//    internal func viewForModule(_ moduleName: String, initialProperties: [String : Any]?) -> RCTRootView {
+//        let rootView: RCTRootView = RCTRootView(
+//            bridge: self.bridgeHeadless,
+//            moduleName: moduleName,
+//            initialProperties: initialProperties)
+//        self.rootView = rootView
+//        return rootView
+//    }
+//    
+//    internal func reinvalidateBridge(){
+//        self.bridgeHeadless.invalidate()
+//        self.bridgeHeadless = RCTBridge.init(delegate: self, launchOptions: nil)
+//    }
+//}
+//
+//extension RNHeadlessManager: RCTBridgeDelegate {
+//    func sourceURL(for bridge: RCTBridge) -> URL? {
+//        switch getInfoPlist("HyperswitchSource") {
+//        case "LocalHosted":
+//            return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+//        default:
+//            return Bundle(for: RNHeadlessManager.self).url(forResource: "hyperswitch", withExtension: "bundle")
+//        }
+//    }
+//}

package/ios/hyperswitchSDK/Core/NativeModule/RNResponseHandler.swift

@@ -0,0 +1,12 @@
+//
+//  RNResponseHandler.swift
+//  hyperswitch
+//
+//  Created by Harshit Srivastava on 22/10/24.
+//
+
+import Foundation
+
+internal protocol RNResponseHandler {
+    func didReceiveResponse(response: String?, error: Error?) -> Void
+}

package/ios/hyperswitchSDK/Core/NativeModule/RNViewManager.swift

@@ -0,0 +1,90 @@
+//
+//  RNViewManager.swift
+//  Hyperswitch
+//
+//  Created by Shivam Shashank on 09/11/22.
+//
+
+//import Foundation
+//import React
+//
+//internal class RNViewManager: NSObject {
+//
+//  internal var responseHandler: RNResponseHandler?
+//  internal var rootView: RCTRootView?
+//
+//  internal lazy var bridge: RCTBridge = {
+//    RCTBridge.init(delegate: self, launchOptions: nil)
+//  }()
+//
+//
+//  internal static let sharedInstance = RNViewManager()
+//
+//  internal func viewForModule(_ moduleName: String, initialProperties: [String : Any]?) -> RCTRootView {
+//    let rootView: RCTRootView = RCTRootView(
+//      bridge: self.bridge,
+//      moduleName: moduleName,
+//      initialProperties: initialProperties)
+//    self.rootView = rootView
+//    return rootView
+//  }
+//}
+//
+//extension RNViewManager: RCTBridgeDelegate {
+//  func sourceURL(for bridge: RCTBridge) -> URL? {
+//    switch getInfoPlist("HyperswitchSource") {
+//    case "LocalHosted":
+//      return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+//    case "LocalBundle":
+//      return Bundle.main.url(forResource: "hyperswitch", withExtension: "bundle")
+//    default:
+//      return OTAServices.shared.getBundleURL()
+//    }
+//  }
+//}
+
+
+// TODO: #if RCT_NEW_ARCH_ENABLED
+import Foundation
+import React
+import React_RCTAppDelegate
+import ReactAppDependencyProvider
+
+internal class RNFabricManager: RCTDefaultReactNativeFactoryDelegate {
+    
+    internal var responseHandler: RNResponseHandler?
+    internal var rootView: UIView?
+    
+    private var reactNativeFactory: RCTReactNativeFactory? = nil
+    
+    internal static let sharedInstance = RNFabricManager()
+    
+    internal func startReactNative() {
+        self.dependencyProvider = RCTAppDependencyProvider()
+        self.reactNativeFactory = RCTReactNativeFactory(delegate: self)
+    }
+    
+    internal func viewForModule(_ moduleName: String, initialProperties: [String : Any]?) -> UIView? {
+        let rootView = reactNativeFactory?.rootViewFactory.view(
+            withModuleName: moduleName,
+            initialProperties: initialProperties
+        )
+        self.rootView = rootView
+        return rootView
+    }
+    
+    override func sourceURL(for bridge: RCTBridge) -> URL? {
+        return bundleURL()
+    }
+    
+    public override func bundleURL() -> URL? {
+        switch getInfoPlist("HyperswitchSource") {
+        case "LocalHosted":
+            return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+        case "LocalBundle":
+            return Bundle.main.url(forResource: "hyperswitch", withExtension: "bundle")
+        default:
+            return OTAServices.shared.getBundleURL()
+        }
+    }
+}

package/ios/hyperswitchSDK/Core/NativeModule/hyper-Bridging-Header.h

@@ -0,0 +1,9 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTRootView.h>
+#import <React/RCTUtils.h>
+#import <React/RCTConvert.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>