@kingstinct/react-native-healthkit 9.0.6 → 9.0.8

package/ios/CategoryTypeModule.swift

@@ -1,9 +1,7 @@
 import HealthKit
 import NitroModules
 
-
-
-class CategoryTypeModule : HybridCategoryTypeModuleSpec {
+class CategoryTypeModule: HybridCategoryTypeModuleSpec {
     func saveCategorySample(
         identifier: CategoryTypeIdentifier,
         value: Double,
@@ -12,7 +10,7 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
         metadata: AnyMapHolder
     ) throws -> Promise<Bool> {
         let type = try initializeCategoryType(identifier.stringValue)
-        
+
         let sample = HKCategorySample(
             type: type,
             value: Int(value),
@@ -20,7 +18,7 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
             end: endDate,
             metadata: anyMapToDictionary(metadata)
         )
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.save(sample) { (success: Bool, error: Error?) in
@@ -33,15 +31,15 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
             }
         }
     }
-    
+
     func queryCategorySamples(
         identifier: CategoryTypeIdentifier,
-        options: QueryOptionsWithSortOrder?,
+        options: QueryOptionsWithSortOrder?
     ) throws -> Promise<[CategorySample]> {
         let sampleType = try initializeCategoryType(identifier.stringValue)
         let predicate = try createPredicate(filter: options?.filter)
         let queryLimit = getQueryLimit(options?.limit)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKSampleQuery(
@@ -54,36 +52,35 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let samples = samples else {
                         continuation.resume(returning: [])
                         return
                     }
-                    
+
                     let categorySamples = samples.compactMap { sample -> CategorySample? in
                         guard let categorySample = sample as? HKCategorySample else { return nil }
                         return serializeCategorySample(sample: categorySample)
                     }
-                    
+
                     continuation.resume(returning: categorySamples)
                 }
-                
+
                 store.execute(query)
             }
         }
     }
-    
-    
+
     func queryCategorySamplesWithAnchor(
         identifier: CategoryTypeIdentifier,
         options: QueryOptionsWithAnchor
     ) throws -> Promise<CategorySamplesWithAnchorResponse> {
         let sampleType = try initializeCategoryType(identifier.stringValue)
-        
+
         let predicate = try createPredicate(filter: options.filter)
         let queryLimit = getQueryLimit(options.limit)
         let queryAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKAnchoredObjectQuery(
@@ -96,7 +93,7 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let samples = samples else {
                         let response = CategorySamplesWithAnchorResponse(
                             samples: [],
@@ -106,21 +103,21 @@ class CategoryTypeModule : HybridCategoryTypeModuleSpec {
                         continuation.resume(returning: response)
                         return
                     }
-                    
+
                     let categorySamples = samples.compactMap { sample -> CategorySample? in
                         guard let categorySample = sample as? HKCategorySample else { return nil }
                         return serializeCategorySample(sample: categorySample)
                     }
-                    
+
                     let response = CategorySamplesWithAnchorResponse(
                         samples: categorySamples,
                         deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
                         newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
                     )
-                    
+
                     continuation.resume(returning: response)
                 }
-                
+
                 store.execute(query)
             }
         }

package/ios/CharacteristicTypeModule.swift

@@ -1,4 +1,3 @@
-
 import HealthKit
 import NitroModules
 
@@ -6,23 +5,23 @@ class CharacteristicTypeModule: HybridCharacteristicTypeModuleSpec {
     func getBloodTypeAsync() throws -> Promise<BloodType> {
         return Promise.resolved(withResult: try self.getBloodType())
     }
-    
-    func getDateOfBirthAsync() throws -> Promise<Date> {
+
+    func getDateOfBirthAsync() throws -> Promise<Date?> {
         return Promise.resolved(withResult: try self.getDateOfBirth())
     }
-    
+
     func getBiologicalSexAsync() throws -> Promise<BiologicalSex> {
         return Promise.resolved(withResult: try self.getBiologicalSex())
     }
-    
+
     func getFitzpatrickSkinTypeAsync() throws -> Promise<FitzpatrickSkinType> {
         return Promise.resolved(withResult: try self.getFitzpatrickSkinType())
     }
-    
+
     func getWheelchairUseAsync() throws -> Promise<WheelchairUse> {
         return Promise.resolved(withResult: try self.getWheelchairUse())
     }
-    
+
     // Using the global 'store' instance defined in Auth.swift
 
     func getBiologicalSex() throws -> BiologicalSex {
@@ -33,34 +32,50 @@ class CharacteristicTypeModule: HybridCharacteristicTypeModuleSpec {
         throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown biological sex value: \(biologicalSexObject.biologicalSex.rawValue)")
     }
 
-    func getDateOfBirth() throws -> Date {
-        let dateOfBirthComponents = try store.dateOfBirthComponents()
-        
-        if let date = dateOfBirthComponents.date {
-            return date
-        }
-        
-        throw RuntimeError.error(withMessage: "[react-native-healthkit] Date of birth is not available or not set")
-    }
+  func getDateOfBirth() throws -> Date? {
+      do {
+          let components = try store.dateOfBirthComponents()
+          return components.date
+      } catch {
+          let nsError = error as NSError
+
+          // 1️⃣ HealthKit’s documented “no data” error
+          if nsError.domain == HKError.errorDomain,
+             nsError.code   == HKError.Code.errorNoData.rawValue {
+              return nil
+          }
+
+          // 2️⃣ The undocumented generic Obj-C error some OS versions emit
+          if nsError.domain == "Foundation._GenericObjCError",
+             nsError.code   == 0 {
+              return nil
+          }
+
+          // Anything else is a real failure – surface it to JS
+          throw RuntimeError.error(
+              withMessage: "[react-native-healthkit] Failed to get date of birth: \(nsError.localizedDescription)"
+          )
+      }
+  }
 
     func getBloodType() throws -> BloodType {
         let bloodTypeObject = try store.bloodType()
-        
-        if let bloodType = BloodType(rawValue: Int32(bloodTypeObject.bloodType.rawValue)){
+
+        if let bloodType = BloodType(rawValue: Int32(bloodTypeObject.bloodType.rawValue)) {
             return bloodType
         }
-        
+
         throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown blood type value: \(bloodTypeObject.bloodType.rawValue)")
     }
 
     func getFitzpatrickSkinType() throws -> FitzpatrickSkinType {
         if #available(iOS 9.0, *) {
             let skinTypeObject = try store.fitzpatrickSkinType()
-            
+
             if let skinType = FitzpatrickSkinType(rawValue: Int32(skinTypeObject.skinType.rawValue)) {
                 return skinType
             }
-            
+
             throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown Fitzpatrick skin type value: \(skinTypeObject.skinType.rawValue)")
         } else {
             throw RuntimeError.error(withMessage: "Fitzpatrick skin type is not available before iOS 9.0")

package/ios/CorrelationTypeModule.swift

@@ -1,7 +1,7 @@
 import HealthKit
 import NitroModules
 
-class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
+class CorrelationTypeModule: HybridCorrelationTypeModuleSpec {
     func saveCorrelationSample(
         typeIdentifier: CorrelationTypeIdentifier,
         samples: [SampleForSaving],
@@ -10,16 +10,16 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
         metadata: AnyMapHolder
     ) throws -> Promise<Bool> {
         let correlationType = try initializeCorrelationType(typeIdentifier.stringValue)
-        
+
         var initializedSamples = Set<HKSample>()
-        
+
         for sample in samples {
             if let quantitySample = sample as? QuantitySampleForSaving {
                 let quantityTypeId = HKQuantityTypeIdentifier(rawValue: quantitySample.quantityType.stringValue)
                 guard let quantityType = HKSampleType.quantityType(forIdentifier: quantityTypeId) else {
                     continue
                 }
-                
+
                 let unit = HKUnit(from: quantitySample.unit)
                 let quantity = HKQuantity(unit: unit, doubleValue: quantitySample.quantity)
                 let hkQuantitySample = HKQuantitySample(
@@ -30,10 +30,10 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                     metadata: anyMapToDictionary(quantitySample.metadata)
                 )
                 initializedSamples.insert(hkQuantitySample)
-                
+
             } else if let categorySample = sample as? CategorySampleForSaving {
                 let categoryType = try initializeCategoryType(categorySample.categoryType.stringValue)
-                
+
                 let hkCategorySample = HKCategorySample(
                     type: categoryType,
                     value: Int(categorySample.value),
@@ -44,7 +44,7 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                 initializedSamples.insert(hkCategorySample)
             }
         }
-        
+
         let correlation = HKCorrelation(
             type: correlationType,
             start: start,
@@ -52,7 +52,7 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
             objects: initializedSamples,
             metadata: anyMapToDictionary(metadata)
         )
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.save(correlation) { (success: Bool, error: Error?) in
@@ -65,7 +65,7 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
             }
         }
     }
-    
+
     func queryCorrelationSamples(
         typeIdentifier: CorrelationTypeIdentifier,
         from: Date,
@@ -82,7 +82,7 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
             )
           )
         )
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKCorrelationQuery(
@@ -94,12 +94,12 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let correlations = correlations else {
                         continuation.resume(returning: [])
                         return
                     }
-                    
+
                     // Collect all quantity types to get preferred units
                     var quantityTypes = Set<HKQuantityType>()
                     for correlation in correlations {
@@ -109,13 +109,13 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                             }
                         }
                     }
-                    
+
                     store.preferredUnits(for: quantityTypes) { (unitMap: [HKQuantityType: HKUnit], error: Error?) in
                         if let error = error {
                             continuation.resume(throwing: error)
                             return
                         }
-                        
+
                         let serializedCorrelations = correlations.map { correlation -> CorrelationSample in
                             let objects = correlation.objects.compactMap { object -> CorrelationObject? in
                                 if let quantitySample = object as? HKQuantitySample,
@@ -126,13 +126,13 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                                     } catch {
                                         print(error.localizedDescription)
                                     }
-                                    
+
                                 } else if let categorySample = object as? HKCategorySample {
                                     return CorrelationObject.first(serializeCategorySample(sample: categorySample))
                                 }
                                 return nil
                             }
-                            
+
                             return CorrelationSample(
                                 correlationType: CorrelationTypeIdentifier(fromString: correlation.correlationType.identifier)!,
                                 objects: objects,
@@ -141,11 +141,11 @@ class CorrelationTypeModule : HybridCorrelationTypeModuleSpec {
                                 endDate: correlation.endDate
                             )
                         }
-                        
+
                         continuation.resume(returning: serializedCorrelations)
                     }
                 }
-                
+
                 store.execute(query)
             }
         }

package/ios/HeartbeatSeriesModule.swift

@@ -5,7 +5,7 @@ func getHeartbeatSeriesByID(
     seriesUUID: UUID
 ) async -> HKHeartbeatSeriesSample? {
     let seriesPredicate = HKQuery.predicateForObject(with: seriesUUID)
-    
+
     let samples = try! await withCheckedThrowingContinuation {
         (continuation: CheckedContinuation<[HKSample], Error>) in
         let query = HKSampleQuery(
@@ -14,36 +14,36 @@ func getHeartbeatSeriesByID(
             limit: 1,
             sortDescriptors: nil
         ) { (_, results, error) in
-            
+
             if let hasError = error {
                 continuation.resume(throwing: hasError)
                 return
             }
-            
+
             guard let samples = results else {
                 return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
             }
-            
+
             continuation.resume(returning: samples)
         }
         store.execute(query)
     }
-    
+
     guard let heartbeatSeries = samples as? [HKHeartbeatSeriesSample] else {
         return nil
     }
-    
+
     return heartbeatSeries.first ?? nil
 }
 
 @available(iOS 13.0.0, *)
-class HeartbeatSeriesModule : HybridHeartbeatSeriesModuleSpec {
+class HeartbeatSeriesModule: HybridHeartbeatSeriesModuleSpec {
     func queryHeartbeatSeriesSamples(
         options: QueryOptionsWithSortOrder?
     ) throws -> Promise<[HeartbeatSeriesSample]> {
         let predicate = try createPredicate(filter: options?.filter)
         let queryLimit = getQueryLimit(options?.limit)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKSampleQuery(
@@ -58,42 +58,42 @@ class HeartbeatSeriesModule : HybridHeartbeatSeriesModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let samples = samples else {
                         continuation.resume(returning: [])
                         return
                     }
-                    
+
                     Task {
                         do {
                             var serializedSamples: [HeartbeatSeriesSample] = []
-                            
+
                             for sample in samples {
                                 guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
-                                
+
                                 let serialized = try await self.serializeHeartbeatSeriesSample(sample: heartbeatSample)
                                 serializedSamples.append(serialized)
                             }
-                            
+
                             continuation.resume(returning: serializedSamples)
                         } catch {
                             continuation.resume(throwing: error)
                         }
                     }
                 }
-                
+
                 store.execute(query)
             }
         }
     }
-    
+
     func queryHeartbeatSeriesSamplesWithAnchor(
         options: QueryOptionsWithAnchor
     ) throws -> Promise<HeartbeatSeriesSamplesWithAnchorResponse> {
         let predicate = try createPredicate(filter: options.filter)
         let queryLimit = getQueryLimit(options.limit)
         let queryAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKAnchoredObjectQuery(
@@ -106,7 +106,7 @@ class HeartbeatSeriesModule : HybridHeartbeatSeriesModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let samples = samples else {
                         let response = HeartbeatSeriesSamplesWithAnchorResponse(
                             samples: [],
@@ -116,38 +116,38 @@ class HeartbeatSeriesModule : HybridHeartbeatSeriesModuleSpec {
                         continuation.resume(returning: response)
                         return
                     }
-                    
+
                     Task {
                         do {
                             var serializedSamples: [HeartbeatSeriesSample] = []
-                            
+
                             for sample in samples {
                                 guard let heartbeatSample = sample as? HKHeartbeatSeriesSample else { continue }
                                 let serialized = try await self.serializeHeartbeatSeriesSample(sample: heartbeatSample)
                                 serializedSamples.append(serialized)
                             }
-                            
+
                             let response = HeartbeatSeriesSamplesWithAnchorResponse(
                                 samples: serializedSamples,
                                 deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
                                 newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
                             )
-                            
+
                             continuation.resume(returning: response)
                         } catch {
                             continuation.resume(throwing: error)
                         }
                     }
                 }
-                
+
                 store.execute(query)
             }
         }
     }
-    
+
     private func serializeHeartbeatSeriesSample(sample: HKHeartbeatSeriesSample) async throws -> HeartbeatSeriesSample {
         let heartbeats = try await getHeartbeatSeriesHeartbeats(sample: sample)
-        
+
         return HeartbeatSeriesSample(
             uuid: sample.uuid.uuidString,
             device: serializeDevice(hkDevice: sample.device),
@@ -158,31 +158,31 @@ class HeartbeatSeriesModule : HybridHeartbeatSeriesModuleSpec {
             sourceRevision: serializeSourceRevision(sample.sourceRevision)
         )
     }
-    
+
     private func getHeartbeatSeriesHeartbeats(sample: HKHeartbeatSeriesSample) async throws -> [Heartbeat] {
         return try await withCheckedThrowingContinuation { continuation in
             var allBeats: [Heartbeat] = []
-            
-            let query = HKHeartbeatSeriesQuery(heartbeatSeries: sample) { 
+
+            let query = HKHeartbeatSeriesQuery(heartbeatSeries: sample) {
                 (_: HKHeartbeatSeriesQuery, timeSinceSeriesStart: TimeInterval, precededByGap: Bool, done: Bool, error: Error?) in
-                
+
                 if let error = error {
                     continuation.resume(throwing: error)
                     return
                 }
-                
+
                 let heartbeat = Heartbeat(
                     timeSinceSeriesStart: timeSinceSeriesStart,
                     precededByGap: precededByGap
                 )
-                
+
                 allBeats.append(heartbeat)
-                
+
                 if done {
                     continuation.resume(returning: allBeats)
                 }
             }
-            
+
             store.execute(query)
         }
     }