react-native-rook-sdk 1.3.1 → 2.0.0-beta.0

package/android/src/main/java/com/rooksdk/modules/RookSyncModule.kt

@@ -1,5 +1,3 @@
-package com.rooksdk.modules
-
 import android.annotation.SuppressLint
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
@@ -9,18 +7,17 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.google.gson.Gson
-import com.rookmotion.rook.sdk.RookConfigurationManager
 import com.rookmotion.rook.sdk.RookContinuousUploadManager
 import com.rookmotion.rook.sdk.RookDataSources
-import com.rookmotion.rook.sdk.RookEventManager
-import com.rookmotion.rook.sdk.RookSummaryManager
 import com.rookmotion.rook.sdk.RookSyncManager
-import com.rookmotion.rook.sdk.domain.enums.SyncStatus
 import com.rookmotion.rook.sdk.domain.model.SyncStatusWithData
 import com.rooksdk.utils.DatasourcesUtils.dataSourcesToWritableArray
 import com.rooksdk.utils.DatasourcesUtils.mapToDataSourceType
 import com.rooksdk.utils.RookDateTime
+import com.rooksdk.utils.SamsungAvailability
 import com.rooksdk.utils.StringToSyncType
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.model.SHSyncStatusWithData
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -28,7 +25,7 @@ import kotlinx.coroutines.launch
 
 class RookSyncModule(
   reactContext: ReactApplicationContext,
-  rookConfigurationManager: RookConfigurationManager
+  private val rookSamsung: RookSamsung
 ): ReactContextBaseJavaModule(reactContext) {
 
   private val rookContinuousUploadManager by lazy {
@@ -39,14 +36,6 @@ class RookSyncModule(
     RookSyncManager(reactContext)
   }
 
-  private val rookEventManager by lazy {
-    RookEventManager(rookConfigurationManager)
-  }
-
-  private val rookSummaryManager by lazy {
-    RookSummaryManager(rookConfigurationManager)
-  }
-
   private val scope: CoroutineScope by lazy {
     CoroutineScope(SupervisorJob() + Dispatchers.Main)
   }
@@ -73,302 +62,50 @@ class RookSyncModule(
     }
   }
 
-  // Sleep
-  /**
-   * Synchronizes the sleep summary data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncSleepSummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncSleepSummary(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // Body
-  /**
-   * Synchronizes the body summary data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncBodySummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncBodySummary(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // Physical
-  /**
-   * Synchronizes the physical summary data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncPhysicalSummary(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncPhysicalSummary(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Sync all failed summaries
-   */
-  @ReactMethod
-  fun syncPendingSummaries(promise: Promise) {
-    scope.launch {
-      val result = rookSummaryManager.syncPendingSummaries()
-
-      result.fold({
-        promise.resolve(true)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  // MARK: - Events
-  /**
-   * Synchronizes the physical events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncPhysicalEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the blood glucose events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncBloodGlucoseEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBloodGlucoseEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the blood pressure events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncBloodPressureEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBloodPressureEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the body metrics event data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncBodyMetricsEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBodyMetricsEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the body heart Rate events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncBodyHeartRateEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncBodyHeartRateEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the physical heart rate events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncPhysicalHeartRateEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalHeartRateEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the nutrition events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncNutritionEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncNutritionEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the hydration events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
-  @ReactMethod
-  fun syncHydrationEvents(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncHydrationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
-  }
-
-  /**
-   * Synchronizes the physical oxygenation events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
   @ReactMethod
-  fun syncPhysicalOxygenationEvent(date: String, promise: Promise) {
-    scope.launch {
-      val result = rookEventManager.syncPhysicalOxygenationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
-    }
+  fun enableSamsungSync(promise: Promise) {
+     scope.launch {
+       rookSamsung.schedule(true)
+       promise.resolve(true)
+     }
   }
 
-  /**
-   * Synchronizes the body oxygenation events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
   @ReactMethod
-  fun syncBodyOxygenationEvent(date: String, promise: Promise) {
+  fun isSamsungSyncEnabled(promise: Promise) {
     scope.launch {
-      val result = rookEventManager.syncBodyOxygenationEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
+      rookSamsung.isScheduled().fold(
+        {
+          promise.resolve(it)
+        },
+        {
+          promise.reject(it)
+        }
+      )
     }
   }
 
-  /**
-   * Synchronizes the sync temperature events data for the given date.
-   * @param date The date for which to sync the data (in string format).
-   * @param promise A promise object to handle the result (resolved on success, rejected on failure).
-   */
   @ReactMethod
-  fun syncTemperatureEvent(date: String, promise: Promise) {
+  fun disableSamsungSync(promise: Promise) {
     scope.launch {
-      val result = rookEventManager.syncTemperatureEvents(RookDateTime.stringToLocalDate(date))
-
-      result.fold({
-        if (it == SyncStatus.SYNCED) promise.resolve(true)
-        else promise.resolve(false)
-      }, {
-        promise.reject(it)
-      })
+      rookSamsung.cancel()
+      promise.resolve(true)
     }
   }
 
-  /**
-   * Synchronizes all failed events
-   */
   @ReactMethod
-  fun syncPendingEvents(promise: Promise) {
+  fun syncTodaySamsungHealthStepsCount(promise: Promise) {
     scope.launch {
-      val result = rookEventManager.syncPendingEvents()
+      rookSamsung.getTodayStepsCount().fold({
+        when (it) {
+          SHSyncStatusWithData.RecordsNotFound -> {
+            promise.reject("SamsungStepsCount", "Records Not Found")
+          }
 
-      result.fold({
-        promise.resolve(true)
+          is SHSyncStatusWithData.Synced -> {
+            val steps = it.data
+            promise.resolve(steps)
+          }
+        }
       }, {
         promise.reject(it)
       })
@@ -390,7 +127,7 @@ class RookSyncModule(
         {
           when (it) {
             SyncStatusWithData.RecordsNotFound -> {
-              promise.reject("syncTodayHealthConnect", "Records Not Found")
+              promise.reject("HealthConnectStepsCount", "Records Not Found")
             }
 
             is SyncStatusWithData.Synced -> {
@@ -513,6 +250,33 @@ class RookSyncModule(
     }
   }
 
+  @ReactMethod
+  fun syncSHTodayCaloriesCount(promise: Promise) {
+    scope.launch {
+      rookSamsung.getTodayCaloriesCount().fold(
+        {
+          when (it) {
+            SHSyncStatusWithData.RecordsNotFound -> {
+              promise.reject("syncTodayHealthConnect", "Records Not Found")
+            }
+
+            is SHSyncStatusWithData.Synced -> {
+              val data = Arguments.createMap().apply {
+                putDouble("basal", it.data.basal)
+                putDouble("active", it.data.active)
+              }
+
+              promise.resolve(data)
+            }
+          }
+        },
+        {
+          promise.reject(it)
+        }
+      )
+    }
+  }
+
   /**
    * Synchronizes the calories count for the current day from Health Connect.
    * This method queries the Health Connect platform via the Rook SDK to retrieve
@@ -612,6 +376,103 @@ class RookSyncModule(
     }
   }
 
+  @ReactMethod
+  fun shSync(enableLogs: Boolean, callback: Callback) {
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("domain", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      rookSamsung.sync(enableLogs).fold(
+        {
+          callback(null, true)
+        }, {
+          val params = Arguments.createMap().apply {
+            putString("domain", it.localizedMessage ?: it.message)
+          }
+
+          callback.invoke(params, false)
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun shSyncByDate(date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("domain", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      rookSamsung.sync(localDate).fold({ result ->
+        callback.invoke(null, result)
+      }, {
+        val params = Arguments.createMap().apply {
+          putString("domain", it.localizedMessage ?: it.message)
+        }
+
+        callback.invoke(params, false)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun shSyncByDefinition(summary: String, date: String, callback: Callback) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungPillar(summary)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        val params = Arguments.createMap().apply {
+          putString("domain", "Samsung health is not available")
+        }
+
+        callback.invoke(params, false)
+        return@launch
+      }
+
+      rookSamsung.sync(localDate, type).fold({ result ->
+        callback.invoke(null, result)
+      }, {
+        val params = Arguments.createMap().apply {
+          putString("domain", it.localizedMessage ?: it.message)
+        }
+
+        callback.invoke(params, false)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun shSyncEvent(date: String, event: String, promise: Promise) {
+    val localDate = RookDateTime.stringToLocalDate(date)
+    val type = StringToSyncType.stringToSamsungEvent(event)
+
+    scope.launch {
+      if (!SamsungAvailability.isSamsungAvailable(rookSamsung)){
+        promise.reject(Throwable("Samsung health is not available"))
+        return@launch
+      }
+
+      rookSamsung.syncEvents(localDate, type).fold({ result ->
+        promise.resolve(result)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
   override fun getName(): String {
     return "RookSyncModule"
   }

package/android/src/main/java/com/rooksdk/utils/DatasourcesUtils.kt

@@ -1,6 +1,7 @@
 package com.rooksdk.utils
 
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableArray
 import com.rookmotion.rook.sdk.domain.enums.DataSourceType
 import com.rookmotion.rook.sdk.domain.model.DataSource
@@ -46,4 +47,17 @@ object DatasourcesUtils {
     return array
   }
 
+  fun readableArrayToSourceList(sources: ReadableArray): List<Source> {
+    val rawList = sources.toArrayList()
+
+    return rawList
+        .mapNotNull { it as? String }
+        .mapNotNull {
+          try {
+            Source.valueOf(it)
+          } catch (e: IllegalArgumentException) {
+            null
+          }
+        }
+  }
 }

package/android/src/main/java/com/rooksdk/utils/PermissionConversion.kt

@@ -0,0 +1,21 @@
+package com.rooksdk.utils
+
+import com.facebook.react.bridge.ReadableArray
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthPermission
+
+object PermissionConversion {
+
+fun parseSamsungPermissions(rawPermissions: ReadableArray): Set<SamsungHealthPermission> {
+    val rawList = rawPermissions.toArrayList()
+
+    return rawList
+      .mapNotNull { it as? String }
+      .mapNotNull {
+        try {
+          SamsungHealthPermission.valueOf(it)
+        } catch (e: IllegalArgumentException) {
+          null
+        }
+      }.toSet()
+  }
+}

package/android/src/main/java/com/rooksdk/utils/SamsungAvailability.kt

@@ -0,0 +1,21 @@
+package com.rooksdk.utils
+
+import io.tryrook.sdk.samsung.RookSamsung
+import io.tryrook.sdk.samsung.domain.enums.SamsungHealthAvailability
+
+object SamsungAvailability {
+  suspend fun getSamsungHealthAvailabilityOrDefault(rookSamsung: RookSamsung): SamsungHealthAvailability {
+    val result = rookSamsung.checkSamsungHealthAvailability()
+    val defaultValue = SamsungHealthAvailability.NOT_INSTALLED
+
+    return result.getOrDefault(defaultValue)
+  }
+  suspend fun isSamsungAvailable(rookSamsung: RookSamsung): Boolean {
+    val result = rookSamsung.checkSamsungHealthAvailability()
+    val defaultValue = SamsungHealthAvailability.NOT_INSTALLED
+
+    val availability = result.getOrDefault(defaultValue)
+
+    return availability == SamsungHealthAvailability.INSTALLED
+  }
+}

package/android/src/main/java/com/rooksdk/utils/Source.kt

@@ -0,0 +1,6 @@
+package com.rooksdk.utils
+
+enum class Source{
+  HEALTH_CONNECT,
+  SAMSUNG_HEALTH
+}

package/android/src/main/java/com/rooksdk/utils/StringToSyncType.kt

@@ -1,6 +1,7 @@
 package com.rooksdk.utils
 
 import com.rookmotion.rook.sdk.domain.model.SyncType
+import io.tryrook.sdk.samsung.domain.model.SHSyncType
 
 object StringToSyncType {
 
@@ -30,4 +31,28 @@ object StringToSyncType {
     }
   }
 
+  fun stringToSamsungPillar(value: String): SHSyncType.Summary {
+    return when(value.lowercase()) {
+      "sleep" -> SHSyncType.Summary.SLEEP
+      "body" -> SHSyncType.Summary.BODY
+      "physical" -> SHSyncType.Summary.PHYSICAL
+      else -> SHSyncType.Summary.BODY
+    }
+  }
+
+  fun stringToSamsungEvent(value: String): SHSyncType.Event {
+    return when (value.lowercase()) {
+      "activity" -> SHSyncType.Event.ACTIVITY
+      "blood_glucose" -> SHSyncType.Event.BLOOD_GLUCOSE
+      "blood_pressure" -> SHSyncType.Event.BLOOD_PRESSURE
+      "body_metrics" -> SHSyncType.Event.BODY_METRICS
+      "heart_rate" -> SHSyncType.Event.HEART_RATE
+      "hydration" -> SHSyncType.Event.HYDRATION
+      "nutrition" -> SHSyncType.Event.NUTRITION
+      "oxygenation" -> SHSyncType.Event.OXYGENATION
+      "steps" -> SHSyncType.Event.STEPS
+      "calories" -> SHSyncType.Event.CALORIES
+      else -> SHSyncType.Event.STEPS
+    }
+  }
 }

package/lib/commonjs/hooks/index.js

@@ -63,6 +63,12 @@ Object.defineProperty(exports, "useRookSync", {
     return _useRookSync.useRookSync;
   }
 });
+Object.defineProperty(exports, "useRookVariables", {
+  enumerable: true,
+  get: function () {
+    return _useRookVariables.useRookVariables;
+  }
+});
 var _useRookAndroidBackgroundSteps = require("./useRookAndroidBackgroundSteps");
 var _useRookAppleHealth = require("./useRookAppleHealth");
 var _useRookAppleHealthVariables = require("./useRookAppleHealthVariables");
@@ -73,4 +79,5 @@ var _useRookHealthConnect = require("./useRookHealthConnect");
 var _useRookPermissions = require("./useRookPermissions");
 var _useRookSummaries = require("./useRookSummaries");
 var _useRookSync = require("./useRookSync");
+var _useRookVariables = require("./useRookVariables");
 //# sourceMappingURL=index.js.map

package/lib/commonjs/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_useRookAndroidBackgroundSteps","require","_useRookAppleHealth","_useRookAppleHealthVariables","_useRookConfiguration","_useRookDataSources","_useRookEvents","_useRookHealthConnect","_useRookPermissions","_useRookSummaries","_useRookSync"],"sourceRoot":"../../../src","sources":["hooks/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,8BAAA,GAAAC,OAAA;AACA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,4BAAA,GAAAF,OAAA;AACA,IAAAG,qBAAA,GAAAH,OAAA;AACA,IAAAI,mBAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,mBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,YAAA,GAAAT,OAAA","ignoreList":[]}
+{"version":3,"names":["_useRookAndroidBackgroundSteps","require","_useRookAppleHealth","_useRookAppleHealthVariables","_useRookConfiguration","_useRookDataSources","_useRookEvents","_useRookHealthConnect","_useRookPermissions","_useRookSummaries","_useRookSync","_useRookVariables"],"sourceRoot":"../../../src","sources":["hooks/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,8BAAA,GAAAC,OAAA;AACA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,4BAAA,GAAAF,OAAA;AACA,IAAAG,qBAAA,GAAAH,OAAA;AACA,IAAAI,mBAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,mBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,YAAA,GAAAT,OAAA;AACA,IAAAU,iBAAA,GAAAV,OAAA","ignoreList":[]}

package/lib/commonjs/hooks/useRookAppleHealthVariables.js

@@ -12,6 +12,7 @@ var _isRunningOniOS = require("../utils/isRunningOniOS");
 var _nativeModules = _interopRequireDefault(require("../utils/nativeModules"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
+ * @deprecated use instead useRookVariable
  * The `useRookAppleHealthVariable` hook returns an object with a `ready` boolean and an
  * asynchronous function `getTodaySteps` that retrieves the number of steps taken today.
  * @returns The `useRookVariable` hook is returning an object with two properties:

package/lib/commonjs/hooks/useRookAppleHealthVariables.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_RookSyncGateContext","_getNativeModule","_interopRequireDefault","_isModuleReady","_isRunningOniOS","_nativeModules","e","__esModule","default","useRookAppleHealthVariables","rookSync","useRef","getNativeModule","nativeModules","ios","SYNC","state","ready","useRookSyncGateContext","getTodaySteps","isRunningOniOS","isModuleReady","result","current","exports"],"sourceRoot":"../../../src","sources":["hooks/useRookAppleHealthVariables.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AACA,IAAAE,gBAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,eAAA,GAAAL,OAAA;AACA,IAAAM,cAAA,GAAAH,sBAAA,CAAAH,OAAA;AAAmD,SAAAG,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMG,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,MAAMC,QAAQ,GAAG,IAAAC,aAAM,EAAC,IAAAC,wBAAe,EAACC,sBAAa,CAACC,GAAG,CAACC,IAAI,CAAC,CAAC;EAChE,MAAM;IACJC,KAAK,EAAE;MAAEC;IAAM;EACjB,CAAC,GAAG,IAAAC,2CAAsB,EAAC,CAAC;;EAE5B;AACF;AACA;AACA;EACE,MAAMC,aAAa,GAAG,MAAAA,CAAA,KAA2B;IAC/C,IAAAC,8BAAc,EAAC,CAAC;IAChB,IAAAC,4BAAa,EAACJ,KAAK,CAAC;IAEpB,MAAMK,MAAM,GAAG,MAAMZ,QAAQ,CAACa,OAAO,CAACJ,aAAa,CAAC,CAAC;IACrD,OAAOG,MAAM;EACf,CAAC;EAED,OAAO;IACLL,KAAK;IACLE;EACF,CAAC;AACH,CAAC;AAACK,OAAA,CAAAf,2BAAA,GAAAA,2BAAA","ignoreList":[]}
+{"version":3,"names":["_react","require","_RookSyncGateContext","_getNativeModule","_interopRequireDefault","_isModuleReady","_isRunningOniOS","_nativeModules","e","__esModule","default","useRookAppleHealthVariables","rookSync","useRef","getNativeModule","nativeModules","ios","SYNC","state","ready","useRookSyncGateContext","getTodaySteps","isRunningOniOS","isModuleReady","result","current","exports"],"sourceRoot":"../../../src","sources":["hooks/useRookAppleHealthVariables.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA;AACA,IAAAE,gBAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,eAAA,GAAAL,OAAA;AACA,IAAAM,cAAA,GAAAH,sBAAA,CAAAH,OAAA;AAAmD,SAAAG,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMG,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,MAAMC,QAAQ,GAAG,IAAAC,aAAM,EAAC,IAAAC,wBAAe,EAACC,sBAAa,CAACC,GAAG,CAACC,IAAI,CAAC,CAAC;EAChE,MAAM;IACJC,KAAK,EAAE;MAAEC;IAAM;EACjB,CAAC,GAAG,IAAAC,2CAAsB,EAAC,CAAC;;EAE5B;AACF;AACA;AACA;EACE,MAAMC,aAAa,GAAG,MAAAA,CAAA,KAA2B;IAC/C,IAAAC,8BAAc,EAAC,CAAC;IAChB,IAAAC,4BAAa,EAACJ,KAAK,CAAC;IAEpB,MAAMK,MAAM,GAAG,MAAMZ,QAAQ,CAACa,OAAO,CAACJ,aAAa,CAAC,CAAC;IACrD,OAAOG,MAAM;EACf,CAAC;EAED,OAAO;IACLL,KAAK;IACLE;EACF,CAAC;AACH,CAAC;AAACK,OAAA,CAAAf,2BAAA,GAAAA,2BAAA","ignoreList":[]}