react-native-mytatva-rn-sdk 1.2.36 → 1.2.38

package/ios/ViewModel/FinalViewModel.swift

@@ -0,0 +1,648 @@
+//
+//  FinalViewModel.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 31/05/25.
+//
+
+import Foundation
+@objc public class FinalViewModelManager: NSObject {
+    @objc public static let shared = FinalViewModelManager()
+    @objc let viewModel = FinalViewModel()
+
+    private override init() {
+        super.init()
+        viewModel.initialize()
+    }
+    
+//    @objc public func callForObserveTransmitterUnbindStatus() {
+//        let sensorID = UserDefaults.standard.string(forKey: "sensorId") ?? ""
+//        if !sensorID.isEmpty {
+//            viewModel.getStatus()
+//        }
+//    }
+    
+    @objc public func callForObserveTransmitterUnbindStatusWithCompletion(
+        _ completion: @escaping (_ finalResponse: [String: Any]?, _ error: Error?) -> Void
+    ) {
+        // Load JSON data from UserDefaults
+        guard let data = UserDefaults.standard.data(forKey: "CGMStatusItem") else {
+            let error = NSError(
+                domain: "SensorData",
+                code: 404,
+                userInfo: [NSLocalizedDescriptionKey: "No cached response found"]
+            )
+            completion(nil, error)
+            return
+        }
+
+        do {
+            let json = try JSONSerialization.jsonObject(with: data, options: [])
+            // Forward to actual handler, which includes a safety check
+            self.callForObserveTransmitterUnbindStatusWithResponse(json, completion: completion)
+        } catch {
+            completion(nil, NSError(domain: "SensorData", code: 405, userInfo: [NSLocalizedDescriptionKey: "Failed to parse cached JSON"]))
+        }
+    }
+
+
+    @objc public func callForObserveTransmitterUnbindStatusWithResponse(
+        _ response: Any,  // Changed from [String: Any] to Any to add type safety
+        completion: @escaping (_ finalResponse: [String: Any]?, _ error: Error?) -> Void
+    ) {
+        // Ensure response is a dictionary
+        guard let responseDict = response as? [String: Any] else {
+            let error = NSError(
+                domain: "SensorData",
+                code: 406,
+                userInfo: [NSLocalizedDescriptionKey: "Response is not a dictionary"]
+            )
+            completion(nil, error)
+            return
+        }
+
+        guard let status = responseDict["status"] as? String, status == "success",
+              let dataArray = responseDict["data"] as? [[String: Any]],
+              let data = dataArray.first else {
+            let error = NSError(
+                domain: "SensorData",
+                code: 400,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid status or missing data"]
+            )
+            completion(nil, error)
+            return
+        }
+
+        guard let sensorId = data["sensorId"] as? String,
+              let startDate = data["startDate"] as? String,
+              let endDate = data["endDate"] as? String,
+              let statusValue = data["status"] as? String,
+              let daysToExpire = data["daysToExpire"] as? Int else {
+            let error = NSError(
+                domain: "SensorData",
+                code: 401,
+                userInfo: [NSLocalizedDescriptionKey: "Missing or invalid sensor data in 'data'"]
+            )
+            completion(nil, error)
+            return
+        }
+
+        let baseResponse: [String: Any] = [
+            "sensorId": sensorId,
+            "startDate": startDate,
+            "endDate": endDate,
+            "status": statusValue,
+            "daysToExpire": daysToExpire
+        ]
+
+        let finalResponse = self.evaluateUnbindStatus(response: baseResponse, startDate: startDate, endDate: endDate)
+        completion(finalResponse, nil)
+    }
+
+       // MARK: - Main Logic
+    @objc public func evaluateUnbindStatus(
+        response: [String: Any],
+        startDate: String,
+        endDate: String
+    ) -> [String: Any] {
+        let updatedResponse = response
+
+        if viewModel.isCurrentDateInRange(startDate: startDate, endDate: endDate) {
+            print("Current date is in range")
+            if ((viewModel.manager.connectedPeripheral == nil) && !KLTLocalSettingManager.shareInstance().canConnectOtherDevice) {
+                viewModel.manager.startScan()
+                viewModel.debouncer.update(with: .disconnected)
+            }  else {
+                print("here")
+                //debouncer.update(with: .connected)
+                //API.shared.sendStatus(status: .connected) 计算 算法入参
+                if let last = viewModel.manager.currentDevice { }
+                else {
+                    //self.manager.closeBleSensor()
+                    //manager.startScan()
+                    //self.debouncer.update(with: .disconnected)
+                    //debouncer.update(with: .transmitterDisconnectBox)
+                }
+            }
+//                            if KLTBluetoothManager.shared().currentDevice.initialEndDate != nil  {
+//
+        }
+
+        return updatedResponse
+    }
+}
+
+class FinalViewModel: NSObject {
+    var initialPeriod = 0
+    var totalSeconds : TimeInterval = 60 * 60
+    let manager: KLTBluetoothManager!
+    var countdownTimer: Timer?
+    var startScanTimer: Timer?
+    let debouncer = EnumDebouncer<CGMConnectionStatus>()
+
+    
+    @objc public override init() {
+        self.manager = KLTBluetoothManager.shared()
+        super.init()
+        debouncer.onDebounceSuccess = { value in
+            API.shared.sendStatus(status: value)
+            print("Same type held for an hour!")
+        }
+     }
+
+    @objc public func initialize() {
+        //getStatus()
+        startCountDown()
+    
+        if ((manager.connectedPeripheral == nil) && !KLTLocalSettingManager.shareInstance().canConnectOtherDevice) {
+            manager.startScan()
+            debouncer.update(with: .disconnected)
+        }  else {
+            print("here")
+            //debouncer.update(with: .connected)
+            //API.shared.sendStatus(status: .connected) 计算 算法入参
+            if let last = manager.currentDevice { }
+            else {
+                //self.manager.closeBleSensor()
+                //manager.startScan()
+                debouncer.update(with: .disconnected)
+                //debouncer.update(with: .transmitterDisconnectBox)
+            }
+        }
+    }
+    
+    func getStatus(encryptionKey: String = PROD_ENC_KEY,
+                   encryptionIv: String = PROD_ENC_IV) {
+        print("ios token:", TOKEN)
+        let url = URL(string: "https://api-feature2.mytatva.in/api/v8/cgm/status")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        
+        // Set headers
+        //request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.addValue(PROD_API_KEY, forHTTPHeaderField: "api-key")
+        request.addValue(TOKEN, forHTTPHeaderField: "token")
+        
+      
+        // Set request body
+        
+        // Perform request
+        let task = URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("Error: \(error)")
+                return
+            }
+            guard let data = data else {
+                print("No data received")
+                return
+            }
+            if let responseString = String(data: data, encoding: .utf8) {
+                print("===>Server Response: \(responseString)")
+                if let decrypted = Crypto.shared.getDecryptedData(cipherText: responseString, encryptionKey: encryptionKey, encryptionIv: encryptionIv) {
+                    print("===>Decrypted response (for verification): \(decrypted)")
+                    
+                    if let decrptedData = decrypted.data(using: .utf8) {
+                        let decoded = try? JSONDecoder().decode(CGMStatusResponse.self, from: decrptedData)
+                        
+                        guard let sensor = decoded?.data.first,
+                              !sensor.startDate.isEmpty,
+                              !sensor.endDate.isEmpty else {
+                            print("No valid sensor data")
+                            return
+                        }
+                        
+                        let startDateStr = sensor.startDate
+                        let endDateStr = sensor.endDate
+                        
+                        print("Start Date: \(startDateStr)")
+                        print("End Date: \(endDateStr)")
+                        UserDefaults.standard.set(sensor.sensorId, forKey: "sensorId")
+                        if self.isCurrentDateInRange(startDate: startDateStr, endDate: endDateStr) {
+                            print("Current date is in range")
+                            if ((self.manager.connectedPeripheral == nil) && !KLTLocalSettingManager.shareInstance().canConnectOtherDevice) {
+                                self.manager.startScan()
+                                self.debouncer.update(with: .disconnected)
+                            }  else {
+                                print("here")
+                                //debouncer.update(with: .connected)
+                                //API.shared.sendStatus(status: .connected) 计算 算法入参
+                                if let last = self.manager.currentDevice { }
+                                else {
+                                    //self.manager.closeBleSensor()
+                                    //manager.startScan()
+                                    //self.debouncer.update(with: .disconnected)
+                                    //debouncer.update(with: .transmitterDisconnectBox)
+                                }
+                            }
+//                            if KLTBluetoothManager.shared().currentDevice.initialEndDate != nil  {
+//                                self.sendStatus(status: .transmitterDisconnect)
+//                            }
+                        }
+                    }
+                }
+            }
+        }
+        task.resume()
+        
+    }
+    
+    func isCurrentDateInRange(startDate: String, endDate: String) -> Bool {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        guard let start = formatter.date(from: startDate),
+              let end = formatter.date(from: endDate) else {
+            return false
+        }
+        
+        let now = Date()
+        return (now >= start) && (now <= end)
+    }
+    
+    func startCountDown() {
+        
+        // Most recently connected device
+        if let last = manager.currentDevice {
+            let eDevice = EDevice.getEnumDevice(last.advertise?.localName ?? "")
+            initialPeriod = Int(eDevice.initNumber * 3 * 60)
+            // Calculate initialization countdown time
+            if let beginDate = KLTDateFormatter.shared.getDateFromWholeString(last.initialBeginDate ?? "") {
+                let time = Date().timeIntervalSince(beginDate)
+                if Int(time) > self.initialPeriod {
+                    // Initialization completed, normal use
+                    
+                } else {
+                    
+                    // During initialization, notify the initialization page to restart the countdown
+                    totalSeconds = Double(initialPeriod) - TimeInterval(time)
+                    
+                    //for countdownlabel
+                    print(String.getTimeString(with: Int(totalSeconds)))
+
+                    if countdownTimer != nil {
+                        countdownTimer?.invalidate()
+                        countdownTimer = nil
+                    }
+                    countdownTimer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(countdown), userInfo: nil, repeats: true)
+                     
+                }
+            }
+        } else {
+            // no device is connected
+            print("no device is connected")
+        }
+        
+        addAllObservers()
+    }
+    
+    func addAllObservers() {
+        manager.addObserver(self, forKeyPath: "status", options: .new, context: nil)
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(bluetoothEnable(_:)), name: NSNotification.Name("BluetoothEnable"), object: nil)
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(errorStatusFromTransmitter(_:)), name: NSNotification.Name("ErrorStatusFromTransmitter"), object: nil)
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(handleLatestReceiveData(_:)), name: NSNotification.Name(KLTAlertCurrentInInitialNotify), object: nil)
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(updateData(_:)), name: NSNotification.Name(KLTUpdateDataNotify), object: nil)
+    }
+
+    func removeAllObservers() {
+        manager.removeObserver(self, forKeyPath: "status")
+        
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("BluetoothEnable"), object: nil)
+        
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name("ErrorStatusFromTransmitter"), object: nil)
+        
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name(KLTAlertCurrentInInitialNotify), object: nil)
+        
+        NotificationCenter.default.removeObserver(self, name: NSNotification.Name(KLTUpdateDataNotify), object: nil)
+    }
+    
+   
+    func uploadData(data: [ReceiveData]) {
+        let batchSize = 40
+        let batches = stride(from: 0, to: data.count, by: batchSize).map {
+            Array(data[$0..<min($0 + batchSize, data.count)])
+        }
+        uploadBatch(batches: batches, index: 0)
+    }
+
+    private func uploadBatch(batches: [[ReceiveData]], index: Int) {
+        guard index < batches.count else {
+            print("✅ All batches uploaded")
+            return
+        }
+
+        let batch = batches[index]
+        let cgmLogs = batch.map { ReceiveDataToLog(data: $0) }
+        let payload = Payload(logs: cgmLogs)
+
+        API.shared.postCGMData(environment: .stage, data: payload) {
+            print("✅ Batch \(index + 1) uploaded successfully")
+            KLTDatabaseHandler.shared().deleteReceiveDataArray(batch)
+            self.uploadBatch(batches: batches, index: index + 1)
+        } onFailure: { error in
+            print("❌ Failed to upload batch \(index + 1): \(String(describing: error?.localizedDescription))")
+            // Optionally retry or stop here
+        }
+    }
+
+    @objc func updateData(_ notification: Notification) {
+        let data = KLTDatabaseHandler.shared().queryAllReceiveData() as! [ReceiveData]
+        print(data)
+        print("===> all data count: ", data.count)
+        KLTDatabaseHandler.shared().reloadQueryHistoryData()
+        if let device = KLTBluetoothManager.shared().currentDevice {
+            let arrayFromInitial = KLTDatabaseHandler.shared().queryReceiveData(with: device, needUserBG: true) as! [ReceiveData]
+            print(arrayFromInitial)
+            print("===> arrayFromInitial count: ", arrayFromInitial.count)
+            self.uploadData(data: arrayFromInitial)
+        }
+    }
+    
+    @objc func errorStatusFromTransmitter(_ notification: Notification) {
+        guard let receiveData = notification.object as? ReceiveData else { return }
+
+        let errorCode = ErrorCode(rawValue: Int32(receiveData.error?.intValue ?? 0))
+        if errorCode == ErrorCode.ERROR_CODE_FLOODING_WATER {
+            debouncer.update(with: CGMConnectionStatus.moistureDetect)
+            //API.shared.sendStatus(status: .moistureDetect)
+        } else if errorCode == ErrorCode.ERROR_CODE_CURRENT_SMALL || errorCode == ErrorCode.ERROR_CODE_NOISE || errorCode == ErrorCode.ERROR_CODE_SENSITIVITY_ATTENUATION {
+            debouncer.update(with: CGMConnectionStatus.weakSignal)
+            //API.shared.sendStatus(status: .weakSignal)
+        } else if errorCode != ErrorCode.ERROR_CODE_NONE {
+            debouncer.update(with: CGMConnectionStatus.errorCommon)
+            //API.shared.sendStatus(status: .errorCommon)
+        }
+        if receiveData.countdownDays == 0 && receiveData.countdownHours == 0 && receiveData.countdownMinutes == 0 {
+            debouncer.update(with: CGMConnectionStatus.expired)
+            //API.shared.sendStatus(status: .expired)
+        }
+    }
+    
+    @objc func handleLatestReceiveData(_ notification: Notification) {
+        print("====> handleLatestReceiveData")
+        guard let receiveData = notification.object as? ReceiveData else { return }
+
+        let errorCode = ErrorCode(rawValue: Int32(receiveData.error?.intValue ?? 0))
+        
+        let hasExceptionCurrent: Bool = (errorCode == ErrorCode.ERROR_CODE_CURRENT_SMALL || errorCode == ErrorCode.ERROR_CODE_NOISE ||
+                                         errorCode == ErrorCode.ERROR_CODE_SENSITIVITY_ATTENUATION || errorCode == ErrorCode.ERROR_CODE_TAKE_OFF ||
+                                         errorCode == ErrorCode.ERROR_CODE_BREAKAGE || errorCode == ErrorCode.ERROR_CODE_TOUCH ||
+                                         errorCode == ErrorCode.ERROR_CODE_FLOODING_WATER)
+
+        if hasExceptionCurrent {
+            guard let startDate = KLTFormat.getDate(from: manager.currentDevice.initialBeginDate ?? "") else { return }
+
+            // Get current UTC date from local date string
+            let now = Date()
+            let nowString = KLTDateFormatter.shared.getWholeString(from: now)
+            let utcDateString = KLTDateFormatter.shared.getUTCFormatDate(from: nowString) ?? ""
+            guard let currentDate = KLTDateFormatter.shared.getDateFromWholeString(utcDateString) else { return }
+
+            let seconds = Calendar(identifier: .gregorian)
+                .dateComponents([.second], from: startDate, to: currentDate).second ?? 0
+
+            let minutes = seconds / 60
+            if minutes > 17 {
+               
+            }
+        }
+    }
+    
+    @objc func bluetoothEnable(_ notification: Notification) {
+        if let isBluetoothEnabled = notification.object as? Bool {
+            if !isBluetoothEnabled {
+                debouncer.update(with: CGMConnectionStatus.bluetoothOff)
+                //API.shared.sendStatus(status: .bluetoothOff)
+            }
+        }
+        if ((manager.connectedPeripheral == nil) && !KLTLocalSettingManager.shareInstance().canConnectOtherDevice) {
+            manager.startScan()
+        }
+    }
+    
+    @objc func countdown() {
+        if let last = KLTDatabaseHandler.shared().isLatestDeviceDisconnected() {
+            if let beginDate = KLTDateFormatter.shared.getDateFromWholeString(last.initialBeginDate ?? "") {
+                let time = Date().timeIntervalSince(beginDate)
+                totalSeconds = TimeInterval(3600 - Int(time))
+            }
+        }
+
+        if totalSeconds <= 0 {
+            countdownTimer?.invalidate()
+            countdownTimer = nil
+
+            startScanTimer?.invalidate()
+            startScanTimer = nil
+
+            //removeAllObservers()
+
+            //KLTLaunchConfiguration.sharedManager.resetRootViewController(type: .normalUsed)
+            return
+        }
+
+        totalSeconds -= 1
+        print(String.getTimeString(with: Int(totalSeconds)))
+        //countDownValueLabel.text =
+    }
+    
+    override func observeValue(
+        forKeyPath keyPath: String?,
+        of object: Any?,
+        change: [NSKeyValueChangeKey : Any]?,
+        context: UnsafeMutableRawPointer?
+    ) {
+        guard keyPath == "status",
+              let newValue = change?[.newKey] as? Int,
+              let status = BluetoothManagerStatus(rawValue: newValue) else {
+            return
+        }
+        
+        print("===>device status is -> \(status)")
+        
+        switch status {
+            
+        case .disconnected:
+            if KLTLocalSettingManager.shareInstance().canConnectOtherDevice {
+                // Unbind then disconnect
+                endBleSensorCycle()
+            } else {
+                if UserDefaults.standard.integer(forKey: "bgmode") != 1 {
+                    manager.startScan()
+                }
+            }
+            //API.shared.sendStatus(status: .disconnected)
+            print("===>device is disconnected")
+            debouncer.update(with: CGMConnectionStatus.disconnected)
+        case .tryToConnect:
+            //            if UserDefaults.standard.integer(forKey: "bgmode") != 1 {
+            //                DispatchQueue.main.asyncAfter(deadline: .now() + 20) {
+            //                    self.manager.startScan()
+            //                }
+            //            }
+            break
+        case .connected:
+            if let timer = startScanTimer {
+                timer.invalidate()
+                startScanTimer = nil
+            }
+            //API.shared.sendStatus(status: .connected)
+            print("===>device is connected")
+            debouncer.update(with: CGMConnectionStatus.connected)
+        case .timeOut:
+            //            if !KLTLocalSettingManager.shareInstance().canConnectOtherDevice {
+            //                startScanTimer = Timer.scheduledTimer(timeInterval: 20,
+            //                                                      target: self,
+            //                                                      selector: #selector(startScan),
+            //                                                      userInfo: nil,
+            //                                                      repeats: false)
+            //            }
+            print("===>time out")
+            break
+        case .sensorLostPower:
+            sensorLostPower()
+            print("===>sensor lost power")
+        case .updateBindWatchSuccess:
+            //KLTLaunchConfiguration.sharedManager.bindSuccessRootViewController()
+            startCountDown()
+            print("===>Success done")
+        case .closed:
+            debouncer.update(with: CGMConnectionStatus.transmitterDisconnectBox)
+            //API.shared.sendStatus(status: .transmitterDisconnectBox)
+            print("===>closed")
+        default:
+            break
+        }
+    }
+    
+    func sensorLostPower() {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            // Will trigger `BluetoothManagerStatusDisconnected` due to forced disconnection
+            self.manager.forceEndBleSensor()
+        }
+    }
+
+    @objc func startScan() {
+        manager.startScan()
+    }
+
+    func endBleSensorCycle() {
+        if let timer = countdownTimer {
+            timer.invalidate()
+            countdownTimer = nil
+        }
+
+        removeAllObservers()
+
+        print("initial State all end")
+       // KLTLaunchConfiguration.sharedManager.resetRootViewController(.beforeUse)
+    }
+}
+
+
+struct KLTDateFormatter {
+    static let shared = KLTDateFormatter()
+
+    private let calendar = Calendar(identifier: .gregorian)
+    private let locale = Locale(identifier: "en_GB")
+
+    private func configuredFormatter(withFormat format: String, timeZone: TimeZone? = nil) -> DateFormatter {
+        let formatter = DateFormatter()
+        formatter.calendar = calendar
+        formatter.locale = locale
+        formatter.dateFormat = format
+        if let tz = timeZone {
+            formatter.timeZone = tz
+        }
+        return formatter
+    }
+
+    func getWholeString(from date: Date) -> String {
+        return configuredFormatter(withFormat: "yyyy-MM-dd HH:mm:ss").string(from: date)
+    }
+
+    func getDayString(from date: Date) -> String {
+        return configuredFormatter(withFormat: "MM-dd").string(from: date)
+    }
+
+    func getHourString(from date: Date) -> String {
+        let hour = configuredFormatter(withFormat: "HH").string(from: date)
+        return "\(hour):00"
+    }
+
+    func getMinuteString(from date: Date) -> String {
+        return configuredFormatter(withFormat: "HH:mm").string(from: date)
+    }
+
+    func getMinuteDate(from string: String) -> Date? {
+        return configuredFormatter(withFormat: "HH:mm").date(from: string)
+    }
+
+    func getHourDate(from string: String) -> Date? {
+        return configuredFormatter(withFormat: "HH:00").date(from: string)
+    }
+
+    func getDayDate(from string: String) -> Date? {
+        return configuredFormatter(withFormat: "MM-dd").date(from: string)
+    }
+
+    func getDateTime(from string: String) -> Date? {
+        return configuredFormatter(withFormat: "yyyy-MM-dd HH:mm").date(from: string)
+    }
+
+    func getDateFromWholeString(_ string: String) -> Date? {
+        return configuredFormatter(withFormat: "yyyy-MM-dd HH:mm:ss").date(from: string)
+    }
+
+    func getUTCFormatDate(from localDate: String) -> String? {
+        guard let date = getDateFromWholeString(localDate) else { return nil }
+        return configuredFormatter(withFormat: "yyyy-MM-dd HH:mm:ss", timeZone: TimeZone(abbreviation: "UTC")).string(from: date)
+    }
+
+    func getLocalFromUTC(_ utc: String) -> String? {
+        let formatter = configuredFormatter(withFormat: "yyyy-MM-dd HH:mm:ss", timeZone: TimeZone.current)
+        guard let date = formatter.date(from: utc) else { return nil }
+        return getWholeString(from: date)
+    }
+}
+extension String {
+    func klt_contains(_ other: String) -> Bool {
+        return self.range(of: other) != nil
+    }
+
+    func klt_hasValidTransmit() -> Bool {
+        guard self.count >= 2 else { return false }
+        let lastHex = String(self.suffix(2))
+        return lastHex == "00"
+    }
+
+    func reverseToString(groupSize: Int) -> String {
+        guard groupSize > 0 && self.count > groupSize else { return self }
+
+        var result = ""
+        var index = self.count
+
+        while index >= groupSize {
+            let start = self.index(self.startIndex, offsetBy: index - groupSize)
+            let end = self.index(self.startIndex, offsetBy: index)
+            result += self[start..<end]
+            index -= groupSize
+        }
+
+        if index > 0 {
+            let leftover = self.prefix(index)
+            result += leftover
+        }
+
+        return result
+    }
+
+    static func getTimeString(with count: Int) -> String {
+        let hours = String(format: "%02d", count / 3600)
+        let minutes = String(format: "%02d", (count % 3600) / 60)
+        let seconds = String(format: "%02d", count % 60)
+        return "\(hours):\(minutes):\(seconds)"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mytatva-rn-sdk",
-  "version": "1.2.36",
+  "version": "1.2.38",
   "description": "a package to inject data into visit health pwa",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",