@kingstinct/react-native-healthkit 10.1.0 → 11.0.0

package/ios/CoreModule.swift

@@ -304,25 +304,17 @@ class CoreModule: HybridCoreModuleSpec {
 
         let queryId = UUID().uuidString
 
-        func responder(
-            query: HKObserverQuery,
-            handler: @escaping HKObserverQueryCompletionHandler,
-            error: Error?
-        ) {
-            DispatchQueue.main.async {
-                callback(OnChangeCallbackArgs(typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
-                handler()
-            }
-        }
-
         let query = HKObserverQuery(
             sampleType: sampleType,
             predicate: predicate
         ) {
-            (query: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
+            (_: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
             in
 
-            return responder(query: query, handler: handler, error: error)
+            DispatchQueue.main.async {
+                callback(OnChangeCallbackArgs(typeIdentifier: typeIdentifier, errorMessage: error?.localizedDescription))
+                handler()
+            }
 
         }
 
@@ -330,8 +322,6 @@ class CoreModule: HybridCoreModuleSpec {
 
         self._runningQueries.updateValue(query, forKey: queryId)
 
-        // resolve(queryId)
-
         return queryId
     }
 

package/ios/CorrelationTypeModule.swift

@@ -14,7 +14,8 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
         var initializedSamples = Set<HKSample>()
 
         for sample in samples {
-            if let quantitySample = sample as? QuantitySampleForSaving {
+            switch sample {
+            case .second(let quantitySample):
                 let quantityTypeId = HKQuantityTypeIdentifier(rawValue: quantitySample.quantityType.stringValue)
                 guard let quantityType = HKSampleType.quantityType(forIdentifier: quantityTypeId) else {
                     continue
@@ -31,7 +32,7 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
                 )
                 initializedSamples.insert(hkQuantitySample)
 
-            } else if let categorySample = sample as? CategorySampleForSaving {
+            case .first(let categorySample):
                 let categoryType = try initializeCategoryType(categorySample.categoryType.stringValue)
 
                 let hkCategorySample = HKCategorySample(
@@ -45,6 +46,10 @@ class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
             }
         }
 
+      if initializedSamples.isEmpty {
+          throw RuntimeError.error(withMessage: "[react-native-healthkit] No valid samples to create correlation sample")
+      }
+
         let correlation = HKCorrelation(
             type: correlationType,
             start: start,

package/ios/QuantityTypeModule.swift

@@ -49,6 +49,66 @@ func queryQuantitySamplesInternal(
 
 }
 
+func serializeStatistics(gottenStats: HKStatistics, unit: HKUnit) -> QueryStatisticsResponse {
+  var response = QueryStatisticsResponse()
+
+  response.startDate = gottenStats.startDate
+  response.endDate = gottenStats.endDate
+
+  if let averageQuantity = gottenStats.averageQuantity() {
+      response.averageQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: averageQuantity.doubleValue(for: unit)
+      )
+  }
+  if let maximumQuantity = gottenStats.maximumQuantity() {
+      response.maximumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: maximumQuantity.doubleValue(for: unit)
+      )
+  }
+  if let minimumQuantity = gottenStats.minimumQuantity() {
+      response.minimumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: minimumQuantity.doubleValue(for: unit)
+      )
+  }
+  if let sumQuantity = gottenStats.sumQuantity() {
+      response.sumQuantity = Quantity(
+          unit: unit.unitString,
+          quantity: sumQuantity.doubleValue(for: unit)
+      )
+  }
+
+  if #available(iOS 12, *) {
+      if let mostRecent = gottenStats.mostRecentQuantity() {
+          response.mostRecentQuantity = Quantity(
+              unit: unit.unitString,
+              quantity: mostRecent.doubleValue(for: unit)
+          )
+      }
+
+      if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
+          response.mostRecentQuantityDateInterval = QuantityDateInterval(
+              from: mostRecentDateInterval.start,
+              to: mostRecentDateInterval.end
+          )
+      }
+  }
+
+  if #available(iOS 13, *) {
+      if let duration = gottenStats.duration() {
+          let durationUnit = HKUnit.second()
+          response.duration = Quantity(
+              unit: durationUnit.unitString,
+              quantity: duration.doubleValue(for: durationUnit)
+          )
+      }
+  }
+
+  return response
+}
+
 func saveQuantitySampleInternal(
   typeIdentifier: HKQuantityType,
   unitString: String,
@@ -190,61 +250,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                             return
                         }
 
-                        var response = QueryStatisticsResponse()
-
-                        response.startDate = gottenStats.startDate
-                        response.endDate = gottenStats.endDate
-
-                        if let averageQuantity = gottenStats.averageQuantity() {
-                            response.averageQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: averageQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let maximumQuantity = gottenStats.maximumQuantity() {
-                            response.maximumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: maximumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let minimumQuantity = gottenStats.minimumQuantity() {
-                            response.minimumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: minimumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let sumQuantity = gottenStats.sumQuantity() {
-                            response.sumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: sumQuantity.doubleValue(for: unit)
-                            )
-                        }
-
-                        if #available(iOS 12, *) {
-                            if let mostRecent = gottenStats.mostRecentQuantity() {
-                                response.mostRecentQuantity = Quantity(
-                                    unit: unit.unitString,
-                                    quantity: mostRecent.doubleValue(for: unit)
-                                )
-                            }
-
-                            if let mostRecentDateInterval = gottenStats.mostRecentQuantityDateInterval() {
-                                response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                    from: mostRecentDateInterval.start,
-                                    to: mostRecentDateInterval.end
-                                )
-                            }
-                        }
-
-                        if #available(iOS 13, *) {
-                            if let duration = gottenStats.duration() {
-                                let durationUnit = HKUnit.second()
-                                response.duration = Quantity(
-                                    unit: durationUnit.unitString,
-                                    quantity: duration.doubleValue(for: durationUnit)
-                                )
-                            }
-                        }
+                        var response = serializeStatistics(gottenStats: gottenStats, unit: unit)
 
                         continuation.resume(returning: response)
                     }
@@ -326,61 +332,7 @@ class QuantityTypeModule: HybridQuantityTypeModuleSpec {
                     }
 
                     statistics.enumerateStatistics(from: enumerateFrom, to: enumerateTo) { stats, _ in
-                        var response = QueryStatisticsResponse()
-
-                        response.startDate = stats.startDate
-                        response.endDate = stats.endDate
-
-                        if let averageQuantity = stats.averageQuantity() {
-                            response.averageQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: averageQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let maximumQuantity = stats.maximumQuantity() {
-                            response.maximumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: maximumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let minimumQuantity = stats.minimumQuantity() {
-                            response.minimumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: minimumQuantity.doubleValue(for: unit)
-                            )
-                        }
-                        if let sumQuantity = stats.sumQuantity() {
-                            response.sumQuantity = Quantity(
-                                unit: unit.unitString,
-                                quantity: sumQuantity.doubleValue(for: unit)
-                            )
-                        }
-
-                        if #available(iOS 12, *) {
-                            if let mostRecent = stats.mostRecentQuantity() {
-                                response.mostRecentQuantity = Quantity(
-                                    unit: unit.unitString,
-                                    quantity: mostRecent.doubleValue(for: unit)
-                                )
-                            }
-
-                            if let mostRecentDateInterval = stats.mostRecentQuantityDateInterval() {
-                                response.mostRecentQuantityDateInterval = QuantityDateInterval(
-                                    from: mostRecentDateInterval.start,
-                                    to: mostRecentDateInterval.end
-                                )
-                            }
-                        }
-
-                        if #available(iOS 13, *) {
-                            if let duration = stats.duration() {
-                                let durationUnit = HKUnit.second()
-                                response.duration = Quantity(
-                                    unit: durationUnit.unitString,
-                                    quantity: duration.doubleValue(for: durationUnit)
-                                )
-                            }
-                        }
+                        var response = serializeStatistics(gottenStats: stats, unit: unit)
 
                         responseArray.append(response)
                     }

package/ios/Serializers.swift

@@ -70,90 +70,61 @@ func serializeSource(_ source: HKSource) -> SourceProxy {
     )
 }
 
-func getUnitForQuantityType(quantityType: HKQuantityType) -> HKUnit? {
-    if quantityType.is(compatibleWith: HKUnit.percent()) {
-        return HKUnit.percent()
+func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
+    guard let quantity = quantity else {
+        return nil
     }
 
-    if quantityType.is(compatibleWith: HKUnit.second()) {
-        return HKUnit.second()
+    if quantity.is(compatibleWith: HKUnit.percent()) {
+        return serializeQuantityTyped(unit: HKUnit.percent(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.kilocalorie()) {
-        return HKUnit.kilocalorie()
+    if quantity.is(compatibleWith: HKUnit.second()) {
+        return serializeQuantityTyped(unit: HKUnit.second(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.count()) {
-        return HKUnit.count()
+    if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
+        return serializeQuantityTyped(unit: HKUnit.kilocalorie(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: HKUnit.meter()) {
-        return HKUnit.meter()
+    if quantity.is(compatibleWith: HKUnit.count()) {
+        return serializeQuantityTyped(unit: HKUnit.count(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: SpeedUnit) {
-        return SpeedUnit
+    if quantity.is(compatibleWith: HKUnit.meter()) {
+        return serializeQuantityTyped(unit: HKUnit.meter(), quantity: quantity)
     }
 
-    if quantityType.is(compatibleWith: METUnit) {
-        return METUnit
+    if quantity.is(compatibleWith: HKUnit.degreeCelsius()) {
+        return serializeQuantityTyped(unit: HKUnit.degreeCelsius(), quantity: quantity)
     }
 
-    if #available(iOS 11, *) {
-        if quantityType.is(compatibleWith: HKUnit.internationalUnit()) {
-            return HKUnit.internationalUnit()
-        }
+    if quantity.is(compatibleWith: HKUnit.atmosphere()) {
+        return serializeQuantityTyped(unit: HKUnit.atmosphere(), quantity: quantity)
     }
 
-    if #available(iOS 13, *) {
-        if quantityType.is(compatibleWith: HKUnit.hertz()) {
-            return HKUnit.hertz()
-        }
-        if quantityType.is(compatibleWith: HKUnit.decibelHearingLevel()) {
-            return HKUnit.decibelHearingLevel()
-        }
+    if quantity.is(compatibleWith: HKUnit.gram()) {
+        return serializeQuantityTyped(unit: HKUnit.gram(), quantity: quantity)
     }
 
-    if #available(iOS 17.0, *) {
-        if quantityType.is(compatibleWith: HKUnit.lux()) {
-            return HKUnit.lux()
-        }
+    if quantity.is(compatibleWith: HKUnit.liter()) {
+        return serializeQuantityTyped(unit: HKUnit.liter(), quantity: quantity)
     }
 
-#if compiler(>=6)
-    if #available(iOS 18.0, *) {
-        if quantityType.is(compatibleWith: HKUnit.appleEffortScore()) {
-            return HKUnit.appleEffortScore()
-        }
+    if quantity.is(compatibleWith: HKUnit.volt()) {
+        return serializeQuantityTyped(unit: HKUnit.volt(), quantity: quantity)
     }
-#endif
 
-    return nil
-}
-
-func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
-    guard let quantity = quantity else {
-        return nil
+    if quantity.is(compatibleWith: HKUnit.hertz()) {
+        return serializeQuantityTyped(unit: HKUnit.hertz(), quantity: quantity)
     }
 
-    if quantity.is(compatibleWith: HKUnit.percent()) {
-        return serializeQuantityTyped(unit: HKUnit.percent(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.second()) {
-        return serializeQuantityTyped(unit: HKUnit.second(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
-        return serializeQuantityTyped(unit: HKUnit.kilocalorie(), quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: HKUnit.count()) {
-        return serializeQuantityTyped(unit: HKUnit.count(), quantity: quantity)
+    if quantity.is(compatibleWith: SpeedUnit) {
+        return serializeQuantityTyped(unit: SpeedUnit, quantity: quantity)
     }
 
-    if quantity.is(compatibleWith: HKUnit.meter()) {
-        return serializeQuantityTyped(unit: HKUnit.meter(), quantity: quantity)
+    if quantity.is(compatibleWith: METUnit) {
+        return serializeQuantityTyped(unit: METUnit, quantity: quantity)
     }
 
     if #available(iOS 11, *) {
@@ -171,6 +142,16 @@ func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
         }
     }
 
+    if #available(iOS 16.0, *) {
+      if quantity.is(compatibleWith: HKUnit.watt()) {
+          return serializeQuantityTyped(unit: HKUnit.watt(), quantity: quantity)
+      }
+
+      if quantity.is(compatibleWith: HKUnit.degreeAngle()) {
+        return serializeQuantityTyped(unit: HKUnit.degreeAngle(), quantity: quantity)
+      }
+    }
+
     if #available(iOS 17.0, *) {
         if quantity.is(compatibleWith: HKUnit.lux()) {
             return serializeQuantityTyped(unit: HKUnit.lux(), quantity: quantity)
@@ -185,14 +166,6 @@ func serializeUnknownQuantityTyped(quantity: HKQuantity?) -> Quantity? {
     }
 #endif
 
-    if quantity.is(compatibleWith: SpeedUnit) {
-        return serializeQuantityTyped(unit: SpeedUnit, quantity: quantity)
-    }
-
-    if quantity.is(compatibleWith: METUnit) {
-        return serializeQuantityTyped(unit: METUnit, quantity: quantity)
-    }
-
     return nil
 }
 

package/ios/WorkoutProxy.swift

@@ -149,17 +149,16 @@ func getSerializedWorkoutLocations(
         previousLocation: i == 0 ? nil : routeCLLocations[i - 1]
       )
     }
-    // let routeInfos: WorkoutRoute = ["locations": routeLocations]
 
     allRoutes.append(
       WorkoutRoute(
         locations: routeLocations,
-        HKMetadataKeySyncIdentifier: routeMetadata.getString(
+        HKMetadataKeySyncIdentifier: routeMetadata.isString(key: "HKMetadataKeySyncIdentifier") ?  routeMetadata.getString(
           key: "HKMetadataKeySyncIdentifier"
-        ),
-        HKMetadataKeySyncVersion: routeMetadata.getDouble(
+        ) : nil,
+        HKMetadataKeySyncVersion: routeMetadata.isDouble(key: "HKMetadataKeySyncVersion") ? routeMetadata.getDouble(
           key: "HKMetadataKeySyncVersion"
-        )
+        ) : nil
       )
     )
   }
@@ -194,9 +193,39 @@ func saveWorkoutRouteInternal(
 }
 
 class WorkoutProxy: HybridWorkoutProxySpec {
+
+  // Return a Promise instead of directly returning the value; wrap async logic.
+  func getStatistic(quantityType: QuantityTypeIdentifier, unitOverride: String?) throws -> Promise<QueryStatisticsResponse?> {
+    return Promise.async {
+      if #available(iOS 16.0, *) {
+        let type = try initializeQuantityType(quantityType.stringValue)
+        if let stats = self.workout.statistics(for: type) {
+          let unit = try await getUnitToUse(unitOverride: unitOverride, quantityType: type)
+          return serializeStatistics(gottenStats: stats, unit: unit)
+        }
+      }
+      return nil
+    }
+  }
+
+  func getAllStatistics() throws -> Promise<[String: QueryStatisticsResponse]> {
+    return Promise.async {
+      var result: [String: QueryStatisticsResponse] = [:]
+      if #available(iOS 16.0, *) {
+        let statsMap = self.workout.allStatistics
+        for (quantityType, stats) in statsMap {
+          let unit = try await getUnitToUse(unitOverride: nil, quantityType: quantityType)
+          let serialized = serializeStatistics(gottenStats: stats, unit: unit)
+          result[quantityType.identifier] = serialized
+        }
+      }
+      return result
+    }
+  }
+
   func toJSON(key: String?) throws -> WorkoutSample {
-    if key != nil && key?.isEmpty != true {
-      print("WorkoutProxy does not support toJSON with key: \(key!)")
+    if let key = key, !key.isEmpty {
+      print("WorkoutProxy does not support toJSON with key: \(key)")
     }
 
     return WorkoutSample(
@@ -204,10 +233,6 @@ class WorkoutProxy: HybridWorkoutProxySpec {
       device: self.device,
       workoutActivityType: self.workoutActivityType,
       duration: self.duration,
-      totalDistance: self.totalDistance,
-      totalEnergyBurned: self.totalEnergyBurned,
-      totalSwimmingStrokeCount: self.totalSwimmingStrokeCount,
-      totalFlightsClimbed: self.totalFlightsClimbed,
       startDate: self.startDate,
       endDate: self.endDate,
       metadata: self.metadata,
@@ -286,7 +311,7 @@ class WorkoutProxy: HybridWorkoutProxySpec {
   var totalEnergyBurned: Quantity? {
     get {
       return serializeQuantityTyped(
-        unit: energyUnit,
+        unit: HKUnit.kilocalorie(),
         quantityNullable: workout.totalEnergyBurned
       )
     }
@@ -314,8 +339,6 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     return nil
   }
 
-  var energyUnit: HKUnit
-
   var startDate: Date {
     get {
       return workout.startDate
@@ -377,14 +400,9 @@ class WorkoutProxy: HybridWorkoutProxySpec {
     return nil
   }
 
-  let distanceUnit: HKUnit
-
   private let workout: HKWorkout
 
-  init(workout: HKWorkout, distanceUnit: HKUnit, energyUnit: HKUnit) {
-    self.energyUnit = energyUnit
-    self.distanceUnit = distanceUnit
-
+  init(workout: HKWorkout) {
     self.workout = workout
   }
 

package/ios/WorkoutsModule.swift

@@ -57,10 +57,6 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
         let limit = getQueryLimit(options.limit)
 
         return Promise.async {
-            let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
-
-            let distanceUnit = try await getUnitToUse(unitOverride: options.distanceUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
-
             return try await withCheckedThrowingContinuation { continuation in
                 let q = HKSampleQuery(
                     sampleType: .workoutType(),
@@ -79,9 +75,7 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
                     let workoutProxies = samples.compactMap { s in
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
-                                workout: workout,
-                                distanceUnit: distanceUnit,
-                                energyUnit: energyUnit
+                                workout: workout
                             )
                         }
                         return nil
@@ -221,9 +215,11 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    store.add(initializedSamples, to: workout) { (_, error: Error?) in
-                        if let error = error {
-                            return continuation.resume(throwing: error)
+                    if !initializedSamples.isEmpty {
+                        store.add(initializedSamples, to: workout) { (_, error: Error?) in
+                            if let error = error {
+                                return continuation.resume(throwing: error)
+                            }
                         }
                     }
                     return continuation.resume()
@@ -231,9 +227,7 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
             }) as Void
 
             return WorkoutProxy.init(
-                workout: workout,
-                distanceUnit: .meter(),
-                energyUnit: .kilocalorie()
+                workout: workout
             )
         }
     }
@@ -246,9 +240,6 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
         let actualAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
 
         return Promise.async {
-            let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
-
-            let distanceUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
 
             return try await withCheckedThrowingContinuation { continuation in
                 let q = HKAnchoredObjectQuery(
@@ -280,8 +271,6 @@ class WorkoutsModule: HybridWorkoutsModuleSpec {
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
                                 workout: workout,
-                                distanceUnit: distanceUnit,
-                                energyUnit: energyUnit
                             )
                         }
                         return nil

package/lib/commonjs/hooks/useMostRecentWorkout.js

@@ -10,17 +10,10 @@ const useSubscribeToChanges_1 = __importDefault(require("./useSubscribeToChanges
 /**
  * @returns the most recent workout sample.
  */
-function useMostRecentWorkout(options) {
+function useMostRecentWorkout() {
     const [workout, setWorkout] = (0, react_1.useState)();
-    const optionsRef = (0, react_1.useRef)(options);
-    (0, react_1.useEffect)(() => {
-        optionsRef.current = options;
-    }, [options]);
     const update = (0, react_1.useCallback)(async () => {
-        setWorkout(await (0, getMostRecentWorkout_1.default)({
-            energyUnit: optionsRef.current?.energyUnit,
-            distanceUnit: optionsRef.current?.distanceUnit,
-        }));
+        setWorkout(await (0, getMostRecentWorkout_1.default)());
     }, []);
     (0, react_1.useEffect)(() => {
         void update();

package/lib/commonjs/hooks/useWorkoutById.js

@@ -22,10 +22,7 @@ function useWorkoutById(uuid, options) {
         setIsLoading(true);
         setError(null);
         try {
-            const fetchedWorkout = await (0, getWorkoutById_1.default)(uuid, {
-                energyUnit: optionsRef.current?.energyUnit,
-                distanceUnit: optionsRef.current?.distanceUnit,
-            });
+            const fetchedWorkout = await (0, getWorkoutById_1.default)(uuid);
             setWorkout(fetchedWorkout);
         }
         catch (err) {

package/lib/commonjs/utils/getMostRecentWorkout.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const modules_1 = require("../modules");
-const getMostRecentWorkout = async (options) => {
+const getMostRecentWorkout = async () => {
     const workouts = await modules_1.Workouts.queryWorkoutSamples({
         limit: 1,
         ascending: false,
-        energyUnit: options?.energyUnit,
-        distanceUnit: options?.distanceUnit,
     });
     return workouts[0];
 };

package/lib/commonjs/utils/getWorkoutById.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const modules_1 = require("../modules");
-const getWorkoutById = async (uuid, options) => {
+const getWorkoutById = async (uuid) => {
     const workouts = await modules_1.Workouts.queryWorkoutSamples({
         limit: 1,
         filter: {
             uuid: uuid,
         },
-        energyUnit: options?.energyUnit,
-        distanceUnit: options?.distanceUnit,
     });
     return workouts[0];
 };

package/lib/module/hooks/useMostRecentWorkout.js

@@ -1,20 +1,13 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import getMostRecentWorkout from '../utils/getMostRecentWorkout';
 import useSubscribeToChanges from './useSubscribeToChanges';
 /**
  * @returns the most recent workout sample.
  */
-export function useMostRecentWorkout(options) {
+export function useMostRecentWorkout() {
     const [workout, setWorkout] = useState();
-    const optionsRef = useRef(options);
-    useEffect(() => {
-        optionsRef.current = options;
-    }, [options]);
     const update = useCallback(async () => {
-        setWorkout(await getMostRecentWorkout({
-            energyUnit: optionsRef.current?.energyUnit,
-            distanceUnit: optionsRef.current?.distanceUnit,
-        }));
+        setWorkout(await getMostRecentWorkout());
     }, []);
     useEffect(() => {
         void update();