@kingstinct/react-native-healthkit 9.0.7 → 9.0.9

package/ios/WorkoutsModule.swift

@@ -6,55 +6,6 @@ import NitroModules
 import WorkoutKit
 #endif
 
-/*func tryParseWeatherCondition(_ weatherCondition: Int?) -> WeatherCondition? {
-    if let weatherCondition = weatherCondition {
-        return WeatherCondition.init(rawValue: Int32(weatherCondition))
-    }
-    return nil
-}
-
-func deserializeWorkoutMetadata(_ metadata: WorkoutMetadata?) -> [String: Any]? {
-    if let metadata = metadata {
-        var dict = metadata.allMetadata != nil
-        ? anyMapToDictionary(metadata.allMetadata!)
-        : Dictionary<String, Any>()
-        // todo (important): hmm, not sure about the typed props here
-        // dict[""]
-        return dict
-    }
-    return nil
-}
-
-func serializeWorkoutMetadata(_ metadata: [String: Any]?) -> WorkoutMetadata? {
-    if let metadata = metadata {
-        return WorkoutMetadata(
-            // todo: figure out conversions here
-            HKWeatherCondition: tryParseWeatherCondition(metadata["HKWeatherCondition"] as? Int),
-            HKWeatherHumidity: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherHumidity"] as? HKQuantity),
-            HKWeatherTemperature: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherTemperature"] as? HKQuantity),
-            HKAverageMETs: serializeUnknownQuantityTyped(quantity: metadata["HKAverageMETs"] as? HKQuantity),
-            HKElevationAscended: serializeUnknownQuantityTyped(quantity: metadata["HKElevationAscended"] as? HKQuantity),
-            HKIndoorWorkout: metadata["HKIndoorWorkout"] as? Bool,
-            HKExternalUUID: metadata["HKExternalUUID"] as? String,
-            HKTimeZone: metadata["HKTimeZone"] as? String,
-            HKWasUserEntered: metadata["HKWasUserEntered"] as? Bool,
-            HKDeviceSerialNumber: metadata["HKDeviceSerialNumber"] as? String,
-            HKUDIDeviceIdentifier: metadata["HKUDIDeviceIdentifier"] as? String,
-            HKUDIProductionIdentifier: metadata["HKUDIProductionIdentifier"] as? String,
-            HKDigitalSignature: metadata["HKDigitalSignature"] as? String,
-            HKDeviceName: metadata["HKDeviceName"] as? String,
-            HKDeviceManufacturerName: metadata["HKDeviceManufacturerName"] as? String,
-            HKSyncIdentifier: metadata["HKSyncIdentifier"] as? String,
-            HKSyncVersion: metadata["HKSyncVersion"] as? Double,
-            HKWasTakenInLab: metadata["HKWasTakenInLab"] as? Bool,
-            HKReferenceRangeLowerLimit: metadata["HKReferenceRangeLowerLimit"] as? Double,
-            HKReferenceRangeUpperLimit: metadata["HKReferenceRangeUpperLimit"] as? Double,
-            allMetadata: serializeAllMetadata(metadata)
-        )
-    }
-    return nil
-}*/
-
 func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
     return locations.compactMap { location in
         let latitude = location.latitude
@@ -65,7 +16,7 @@ func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
         let course = location.course
         let speed = location.speed
         let timestamp = location.date
-        
+
         let clLocation = CLLocation(
             coordinate: CLLocationCoordinate2D(
                 latitude: latitude,
@@ -76,24 +27,40 @@ func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
             verticalAccuracy: verticalAccuracy,
             course: course,
             speed: speed,
-            timestamp: timestamp,
+            timestamp: timestamp
         )
-        
+
         return clLocation
     }
 }
 
-class WorkoutsModule : HybridWorkoutsModuleSpec {
+class WorkoutsModule: HybridWorkoutsModuleSpec {
+    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) throws -> Promise<Bool> {
+        let configuration = parseWorkoutConfiguration(workoutConfiguration)
+
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                store.startWatchApp(with: configuration) { success, error in
+                  if let error {
+                      continuation.resume(throwing: RuntimeError.error(withMessage: error.localizedDescription))
+                  }
+
+                  continuation.resume(returning: success)
+                }
+            }
+        }
+    }
+
     func queryWorkoutSamples(options: WorkoutQueryOptions) throws -> Promise<[HybridWorkoutProxySpec]> {
         let predicate = try createPredicateForWorkout(filter: options.filter)
-        
+
         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(),
@@ -104,11 +71,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     guard let samples = samples else {
                         return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
                     }
-                    
+
                     let workoutProxies = samples.compactMap { s in
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
@@ -119,15 +86,15 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                         }
                         return nil
                     }
-                    
+
                     return continuation.resume(returning: workoutProxies)
                 }
-                
+
                 store.execute(q)
             }
         }
     }
-    
+
     func saveWorkoutSample(
         workoutActivityType: WorkoutActivityType,
         quantities: [QuantitySampleForSaving],
@@ -136,18 +103,18 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
         totals: WorkoutTotals,
         metadata: AnyMapHolder
     ) throws -> Promise<String> {
-        
+
         let type = try initializeWorkoutActivityType(UInt(workoutActivityType.rawValue))
-        
+
         // if start and end both exist,  ensure that start date is before end date
         if let startDate = startDate as Date?, let endDate = endDate as Date? {
             if startDate > endDate {
                 throw RuntimeError.error(withMessage: "endDate must not be less than startDate")
             }
         }
-        
+
         let metadataDeserialized = anyMapToDictionary(metadata)
-        
+
         var totalEnergyBurned: HKQuantity?
         var totalDistance: HKQuantity?
         var totalSwimmingStrokeCount: HKQuantity?
@@ -161,23 +128,23 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
             let quantityEnd = quantity.endDate
             let unit = HKUnit.init(from: unitStr)
             let quantity = HKQuantity.init(unit: unit, doubleValue: quantityVal)
-            
+
             if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
                 totalEnergyBurned = quantity
             }
-            
+
             if quantity.is(compatibleWith: HKUnit.meter()) {
                 totalDistance = quantity
             }
-            
+
             if type.identifier == HKWorkoutSortIdentifierTotalSwimmingStrokeCount {
                 totalSwimmingStrokeCount = quantity
             }
-            
+
             if type.identifier == HKWorkoutSortIdentifierTotalFlightsClimbed {
                 totalFlightsClimbed = quantity
             }
-            
+
             return HKQuantitySample.init(
                 type: type,
                 quantity: quantity,
@@ -186,21 +153,21 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 metadata: metadataDeserialized
             )
         }
-        
+
         // if totals are provided override samples
         let rawTotalDistance = totals.distance ?? 0.0
         let rawTotalEnergy = totals.energyBurned ?? 0.0
-        
+
         if rawTotalDistance != 0.0 {
             totalDistance = HKQuantity(unit: .meter(), doubleValue: rawTotalDistance)
         }
         if rawTotalEnergy != 0.0 {
             totalEnergyBurned = HKQuantity(unit: .kilocalorie(), doubleValue: rawTotalEnergy)
         }
-        
+
         // creating workout
         var workout: HKWorkout?
-        
+
         if totalSwimmingStrokeCount != nil {
             workout = HKWorkout.init(
                 activityType: type,
@@ -230,7 +197,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 }
             }
         }
-        
+
         if workout == nil {
             workout = HKWorkout.init(
                 activityType: type,
@@ -242,11 +209,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                 metadata: metadataDeserialized
             )
         }
-        
+
         guard let workout = workout else {
             throw RuntimeError.error(withMessage: "Could not create workout")
         }
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 // saving workout, samples and route
@@ -254,11 +221,11 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     if initializedSamples.isEmpty {
                         return continuation.resume(returning: workout.uuid.uuidString)
                     }
-                    
+
                     store.add(initializedSamples, to: workout) { (_, error: Error?) in
                         if let error = error {
                             return continuation.resume(throwing: error)
@@ -269,37 +236,19 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
             }
         }
     }
-    
-    
-    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) -> Promise<Bool>
-    {
-        let configuration = parseWorkoutConfiguration(workoutConfiguration)
-        
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                store.startWatchApp(with: configuration) { success, error in
-                    if let error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        continuation.resume(returning: success)
-                    }
-                }
-            }
-        }
-    }
-    
+
     func queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor) throws -> Promise<QueryWorkoutSamplesWithAnchorResponse> {
         let predicate = try createPredicateForWorkout(filter: options.filter)
-        
+
         let limit = getQueryLimit(options.limit)
-        
+
         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(
                     type: .workoutType(),
@@ -317,7 +266,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                     if let error = error {
                         return continuation.resume(throwing: error)
                     }
-                    
+
                     guard let samples = s, let newAnchor = newAnchor else {
                         return continuation.resume(
                             throwing: RuntimeError.error(
@@ -325,7 +274,7 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                             )
                         )
                     }
-                    
+
                     let workoutProxies = samples.compactMap { s in
                         if let workout = s as? HKWorkout {
                             return WorkoutProxy.init(
@@ -336,20 +285,20 @@ class WorkoutsModule : HybridWorkoutsModuleSpec {
                         }
                         return nil
                     }
-                    
+
                     let deletedSamples = deletedSamples?.map({ sample in
                         return serializeDeletedSample(sample: sample)
                     }) ?? []
-                    
+
                     let returnValue = QueryWorkoutSamplesWithAnchorResponse(
                         workouts: workoutProxies,
                         deletedSamples: deletedSamples,
                         newAnchor: serializeAnchor(anchor: newAnchor)!
                     )
-                    
+
                     return continuation.resume(returning: returnValue)
                 }
-                
+
                 store.execute(q)
             }
         }

package/lib/commonjs/healthkit.js

@@ -81,7 +81,7 @@ function queryCategorySamples(_categoryTypeIdentifier) {
     }
     return Promise.resolve([]);
 }
-function queryCategorySamplesWithAnchor(_categoryTypeIdentifier) {
+function queryCategorySamplesWithAnchor(_categoryTypeIdentifier, _options) {
     if (react_native_1.Platform.OS !== 'ios' && !hasWarned) {
         console.warn(notAvailableError);
         hasWarned = true;

package/lib/module/healthkit.js

@@ -59,7 +59,7 @@ export function queryCategorySamples(_categoryTypeIdentifier) {
     }
     return Promise.resolve([]);
 }
-export function queryCategorySamplesWithAnchor(_categoryTypeIdentifier) {
+export function queryCategorySamplesWithAnchor(_categoryTypeIdentifier, _options) {
     if (Platform.OS !== 'ios' && !hasWarned) {
         console.warn(notAvailableError);
         hasWarned = true;

package/lib/typescript/healthkit.d.ts

@@ -5,6 +5,7 @@ import type { CategorySamplesWithAnchorResponseTyped, CategorySampleTyped } from
 import type { CategoryTypeIdentifier } from './types/CategoryTypeIdentifier';
 import { BiologicalSex, BloodType, FitzpatrickSkinType, WheelchairUse } from './types/Characteristics';
 import type { QuantitySample } from './types/QuantitySample';
+import type { QueryOptionsWithAnchor } from './types/QueryOptions';
 export * from './types';
 export declare const authorizationStatusFor: (type: import("./types").ObjectTypeIdentifier) => AuthorizationStatus;
 export declare const disableAllBackgroundDelivery: () => Promise<boolean>;
@@ -35,12 +36,12 @@ export declare const queryStatisticsCollectionForQuantity: (identifier: import("
 export declare const saveQuantitySample: (identifier: import("./types").QuantityTypeIdentifier, unit: string, value: number, start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare const isQuantityCompatibleWithUnit: (identifier: import("./types").QuantityTypeIdentifier, unit: string) => boolean;
 export declare function queryCategorySamples<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T): Promise<CategorySampleTyped<T>[]>;
-export declare function queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T): Promise<CategorySamplesWithAnchorResponseTyped<T>>;
+export declare function queryCategorySamplesWithAnchor<T extends CategoryTypeIdentifier>(_categoryTypeIdentifier: T, _options: QueryOptionsWithAnchor): Promise<CategorySamplesWithAnchorResponseTyped<T>>;
 export declare const saveCategorySample: <T extends CategoryTypeIdentifier>(identifier: T, value: import("./types").CategoryValueForIdentifier, startDate: Date, endDate: Date, metadata: import("./types").MetadataForCategoryIdentifier<T>) => Promise<boolean>;
 export declare const queryCorrelationSamples: (typeIdentifier: import("./types").CorrelationTypeIdentifier, from: Date, to: Date) => Promise<readonly import("./types").CorrelationSample[]>;
 export declare const saveCorrelationSample: (typeIdentifier: import("./types").CorrelationTypeIdentifier, samples: import("./types").SampleForSaving[], start: Date, end: Date, metadata: import("react-native-nitro-modules").AnyMap) => Promise<boolean>;
 export declare const queryHeartbeatSeriesSamples: (options?: import("./types").QueryOptionsWithSortOrder) => Promise<readonly import("./types").HeartbeatSeriesSample[]>;
-export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: import("./types").QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
+export declare const queryHeartbeatSeriesSamplesWithAnchor: (options: QueryOptionsWithAnchor) => Promise<import("./types").HeartbeatSeriesSamplesWithAnchorResponse>;
 export declare const queryWorkoutSamples: (options: import("./types").WorkoutQueryOptions) => Promise<WorkoutProxy[]>;
 export declare const queryWorkoutSamplesWithAnchor: (options: import("./types").WorkoutQueryOptionsWithAnchor) => Promise<import("./types").QueryWorkoutSamplesWithAnchorResponse>;
 export declare const saveWorkoutSample: (workoutActivityType: import("./types").WorkoutActivityType, quantities: readonly import("./types").QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: import("./types").WorkoutTotals, metadata: import("react-native-nitro-modules").AnyMap) => Promise<string>;

package/lib/typescript/specs/WorkoutsModule.nitro.d.ts

@@ -9,5 +9,8 @@ export interface WorkoutsModule extends HybridObject<{
     saveWorkoutSample(workoutActivityType: WorkoutActivityType, quantities: readonly QuantitySampleForSaving[], startDate: Date, endDate: Date, totals: WorkoutTotals, metadata: AnyMap): Promise<string>;
     queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor): Promise<QueryWorkoutSamplesWithAnchorResponse>;
     queryWorkoutSamples(options: WorkoutQueryOptions): Promise<WorkoutProxy[]>;
+    /**
+     * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1648358-startwatchapp Apple Docs }
+     */
     startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration): Promise<boolean>;
 }

package/nitrogen/generated/ios/ReactNativeHealthkit-Swift-Cxx-Bridge.cpp

@@ -17,7 +17,6 @@
 #include "HybridSourceProxySpecSwift.hpp"
 #include "HybridStateOfMindModuleSpecSwift.hpp"
 #include "HybridWorkoutProxySpecSwift.hpp"
-#include "HybridWorkoutSessionModuleSpecSwift.hpp"
 #include "HybridWorkoutsModuleSpecSwift.hpp"
 #include "ReactNativeHealthkit-Swift-Cxx-Umbrella.hpp"
 
@@ -367,54 +366,14 @@ namespace margelo::nitro::healthkit::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(const std::string& /* errorMessage */)>
+  // pragma MARK: std::function<void(const std::string& /* result */)>
   Func_void_std__string create_Func_void_std__string(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = ReactNativeHealthkit::Func_void_std__string::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::string& errorMessage) mutable -> void {
-      swiftClosure.call(errorMessage);
-    };
-  }
-  
-  // pragma MARK: std::function<void(WorkoutSessionState /* toState */, WorkoutSessionState /* fromState */, std::chrono::system_clock::time_point /* date */)>
-  Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point create_Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutSessionState_WorkoutSessionState_std__chrono__system_clock__time_point::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](WorkoutSessionState toState, WorkoutSessionState fromState, std::chrono::system_clock::time_point date) mutable -> void {
-      swiftClosure.call(static_cast<int>(toState), static_cast<int>(fromState), date);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::vector<RemoteSessionSharableData>& /* data */)>
-  Func_void_std__vector_RemoteSessionSharableData_ create_Func_void_std__vector_RemoteSessionSharableData_(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_std__vector_RemoteSessionSharableData_::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::vector<RemoteSessionSharableData>& data) mutable -> void {
-      swiftClosure.call(data);
-    };
-  }
-  
-  // pragma MARK: std::function<void(WorkoutEventType /* type */)>
-  Func_void_WorkoutEventType create_Func_void_WorkoutEventType(void* _Nonnull swiftClosureWrapper) {
-    auto swiftClosure = ReactNativeHealthkit::Func_void_WorkoutEventType::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](WorkoutEventType type) mutable -> void {
-      swiftClosure.call(static_cast<int>(type));
+    return [swiftClosure = std::move(swiftClosure)](const std::string& result) mutable -> void {
+      swiftClosure.call(result);
     };
   }
   
-  // pragma MARK: std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec>
-  std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpec> create_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(void* _Nonnull swiftUnsafePointer) {
-    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx swiftPart = ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(swiftPart);
-  }
-  void* _Nonnull get_std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_(std__shared_ptr_margelo__nitro__healthkit__HybridWorkoutSessionModuleSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::healthkit::HybridWorkoutSessionModuleSpecSwift>(cppType);
-  #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridWorkoutSessionModuleSpec\" is not implemented in Swift!");
-    }
-  #endif
-    ReactNativeHealthkit::HybridWorkoutSessionModuleSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
-  
   // pragma MARK: std::function<void(const QueryWorkoutSamplesWithAnchorResponse& /* result */)>
   Func_void_QueryWorkoutSamplesWithAnchorResponse create_Func_void_QueryWorkoutSamplesWithAnchorResponse(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = ReactNativeHealthkit::Func_void_QueryWorkoutSamplesWithAnchorResponse::fromUnsafe(swiftClosureWrapper);