@kingstinct/react-native-healthkit 12.1.2 → 12.2.0

package/ios/CategoryTypeModule.swift

@@ -8,118 +8,70 @@ class CategoryTypeModule: HybridCategoryTypeModuleSpec {
         startDate: Date,
         endDate: Date,
         metadata: AnyMap
-    ) throws -> Promise<Bool> {
-        let type = try initializeCategoryType(identifier.stringValue)
+    ) -> Promise<Bool> {
+        return Promise.async {
+          let type = try initializeCategoryType(identifier.stringValue)
 
-        let sample = HKCategorySample(
-            type: type,
-            value: Int(value),
-            start: startDate,
-            end: endDate,
-            metadata: anyMapToDictionary(metadata)
-        )
+          let sample = HKCategorySample(
+              type: type,
+              value: Int(value),
+              start: startDate,
+              end: endDate,
+              metadata: anyMapToDictionary(metadata)
+          )
 
-        return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                store.save(sample) { (success: Bool, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                    } else {
-                        continuation.resume(returning: success)
-                    }
-                }
-            }
+          return try await saveAsync(sample: sample)
         }
     }
 
     func queryCategorySamples(
         identifier: CategoryTypeIdentifier,
-        options: QueryOptionsWithSortOrder?
-    ) throws -> Promise<[CategorySample]> {
-        let sampleType = try initializeCategoryType(identifier.stringValue)
-        let predicate = try createPredicate(filter: options?.filter)
-        let queryLimit = getQueryLimit(options?.limit)
-
+        options: QueryOptionsWithSortOrder
+    ) -> Promise<[CategorySample]> {
         return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                let query = HKSampleQuery(
-                    sampleType: sampleType,
-                    predicate: predicate,
-                    limit: queryLimit,
-                    sortDescriptors: getSortDescriptors(ascending: options?.ascending)
-                ) { (_: HKSampleQuery, samples: [HKSample]?, error: Error?) in
-                    if let error = error {
-                        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)
-            }
+          let sampleType = try initializeCategoryType(identifier.stringValue)
+          let predicate = createPredicateForSamples(options.filter)
+          let sortDescriptors = getSortDescriptors(ascending: options.ascending)
+
+          let samples = try await sampleQueryAsync(
+            sampleType: sampleType,
+            limit: options.limit,
+            predicate: predicate,
+            sortDescriptors: sortDescriptors
+          )
+
+          return samples.compactMap { sample -> CategorySample? in
+              guard let categorySample = sample as? HKCategorySample else { return nil }
+              return serializeCategorySample(sample: categorySample)
+          }
         }
     }
 
     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)
-
+    ) -> Promise<CategorySamplesWithAnchorResponse> {
         return Promise.async {
-            try await withCheckedThrowingContinuation { continuation in
-                let query = HKAnchoredObjectQuery(
-                    type: sampleType,
-                    predicate: predicate,
-                    anchor: queryAnchor,
-                    limit: queryLimit
-                ) { (_: HKAnchoredObjectQuery, samples: [HKSample]?, deletedSamples: [HKDeletedObject]?, newAnchor: HKQueryAnchor?, error: Error?) in
-                    if let error = error {
-                        continuation.resume(throwing: error)
-                        return
-                    }
-
-                    guard let samples = samples else {
-                        let response = CategorySamplesWithAnchorResponse(
-                            samples: [],
-                            deletedSamples: deletedSamples?.map { serializeDeletedSample(sample: $0) } ?? [],
-                            newAnchor: serializeAnchor(anchor: newAnchor) ?? ""
-                        )
-                        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)
-            }
+          let sampleType = try initializeCategoryType(identifier.stringValue)
+          let predicate = createPredicateForSamples(options.filter)
+
+          let response = try await sampleAnchoredQueryAsync(
+            sampleType: sampleType,
+            limit: options.limit,
+            queryAnchor: options.anchor,
+            predicate: predicate
+          )
+
+          let categorySamples = response.samples.compactMap { sample -> CategorySample? in
+              guard let categorySample = sample as? HKCategorySample else { return nil }
+              return serializeCategorySample(sample: categorySample)
+          }
+
+          return CategorySamplesWithAnchorResponse(
+              samples: categorySamples,
+              deletedSamples: response.deletedSamples,
+              newAnchor: response.newAnchor
+          )
         }
     }
 }

package/ios/CharacteristicTypeModule.swift

@@ -2,92 +2,106 @@ import HealthKit
 import NitroModules
 
 class CharacteristicTypeModule: HybridCharacteristicTypeModuleSpec {
-    func getBloodTypeAsync() throws -> Promise<BloodType> {
-        return Promise.resolved(withResult: try self.getBloodType())
+  func getBloodTypeAsync() -> Promise<BloodType> {
+    return Promise.async {
+      return try self.getBloodType()
     }
+  }
 
-    func getDateOfBirthAsync() throws -> Promise<Date?> {
-        return Promise.resolved(withResult: try self.getDateOfBirth())
+  func getDateOfBirthAsync() -> Promise<Date?> {
+    return Promise.async {
+      return try self.getDateOfBirth()
     }
+  }
 
-    func getBiologicalSexAsync() throws -> Promise<BiologicalSex> {
-        return Promise.resolved(withResult: try self.getBiologicalSex())
+  func getBiologicalSexAsync() -> Promise<BiologicalSex> {
+    return Promise.async {
+      return try self.getBiologicalSex()
     }
+  }
 
-    func getFitzpatrickSkinTypeAsync() throws -> Promise<FitzpatrickSkinType> {
-        return Promise.resolved(withResult: try self.getFitzpatrickSkinType())
+  func getFitzpatrickSkinTypeAsync() -> Promise<FitzpatrickSkinType> {
+    return Promise.async {
+      return try self.getFitzpatrickSkinType()
     }
+  }
 
-    func getWheelchairUseAsync() throws -> Promise<WheelchairUse> {
-        return Promise.resolved(withResult: try self.getWheelchairUse())
+  func getWheelchairUseAsync() -> Promise<WheelchairUse> {
+    return Promise.async {
+      return try self.getWheelchairUse()
     }
+  }
 
-    // Using the global 'store' instance defined in Auth.swift
+  // Using the global 'store' instance defined in Auth.swift
 
-    func getBiologicalSex() throws -> BiologicalSex {
-        let biologicalSexObject = try store.biologicalSex()
-        if let biologicalSex = BiologicalSex(rawValue: Int32(biologicalSexObject.biologicalSex.rawValue)) {
-            return biologicalSex
-        }
-        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown biological sex value: \(biologicalSexObject.biologicalSex.rawValue)")
+  func getBiologicalSex() throws -> BiologicalSex {
+    let biologicalSexObject = try store.biologicalSex()
+    if let biologicalSex = BiologicalSex(
+      rawValue: Int32(biologicalSexObject.biologicalSex.rawValue)) {
+      return biologicalSex
     }
+    throw runtimeErrorWithPrefix(
+      "Got unknown biological sex value: \(biologicalSexObject.biologicalSex.rawValue)")
+  }
 
   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)"
-          )
+    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
       }
-  }
 
-    func getBloodType() throws -> BloodType {
-        let bloodTypeObject = try store.bloodType()
+      // Anything else is a real failure – surface it to JS
+      throw runtimeErrorWithPrefix("Failed to get date of birth: \(nsError.localizedDescription)")
+    }
+  }
 
-        if let bloodType = BloodType(rawValue: Int32(bloodTypeObject.bloodType.rawValue)) {
-            return bloodType
-        }
+  func getBloodType() throws -> BloodType {
+    let bloodTypeObject = try store.bloodType()
 
-        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown blood type value: \(bloodTypeObject.bloodType.rawValue)")
+    if let bloodType = BloodType(rawValue: Int32(bloodTypeObject.bloodType.rawValue)) {
+      return bloodType
     }
 
-    func getFitzpatrickSkinType() throws -> FitzpatrickSkinType {
-        if #available(iOS 9.0, *) {
-            let skinTypeObject = try store.fitzpatrickSkinType()
+    throw runtimeErrorWithPrefix(
+      "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
-            }
+      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")
-        }
+      throw runtimeErrorWithPrefix(
+        "Got unknown Fitzpatrick skin type value: \(skinTypeObject.skinType.rawValue)")
     }
+    throw runtimeErrorWithPrefix("Fitzpatrick skin type is not available before iOS 9.0")
+  }
 
-    @available(iOS 10.0, *)
-    func getWheelchairUse() throws -> WheelchairUse {
-        let wheelchairUseObject = try store.wheelchairUse()
-        if let wheelChairUse = WheelchairUse(rawValue: Int32(wheelchairUseObject.wheelchairUse.rawValue)) {
-            return wheelChairUse
-        }
-        throw RuntimeError.error(withMessage: "[react-native-healthkit] Got unknown wheelchair use value: \(wheelchairUseObject.wheelchairUse.rawValue)")
+  @available(iOS 10.0, *)
+  func getWheelchairUse() throws -> WheelchairUse {
+    let wheelchairUseObject = try store.wheelchairUse()
+    if let wheelChairUse = WheelchairUse(
+      rawValue: Int32(wheelchairUseObject.wheelchairUse.rawValue)) {
+      return wheelChairUse
     }
+    throw runtimeErrorWithPrefix(
+      "Got unknown wheelchair use value: \(wheelchairUseObject.wheelchairUse.rawValue)"
+    )
+  }
 }