@kingstinct/react-native-healthkit 9.0.4 → 9.0.6

package/app.plugin.js

@@ -0,0 +1,88 @@
+const {
+  withPlugins,
+  createRunOncePlugin,
+  withEntitlementsPlist,
+  withInfoPlist,
+} = require('@expo/config-plugins')
+
+/**
+ * @typedef ConfigPlugin
+ * @type {import('@expo/config-plugins').ConfigPlugin<T>}
+ * @template T = void
+ */
+
+/**
+ * @typedef InfoPlistConfig
+ * @type {{
+ *  NSHealthShareUsageDescription?: string | boolean,
+ *  NSHealthUpdateUsageDescription?: string | boolean
+ * }}
+ */
+
+/**
+ * @typedef AppPluginConfig
+ * @type {InfoPlistConfig & { background?: boolean }}
+ */
+
+/**
+ * @type {ConfigPlugin<{background: boolean}>}
+ */
+const withEntitlementsPlugin = (
+  config,
+  /**
+   * @type {{background: boolean} | undefined}
+   * */
+  props,
+) =>
+  withEntitlementsPlist(config, (config) => {
+    config.modResults['com.apple.developer.healthkit'] = true
+
+    // background is enabled by default, but possible to opt-out from
+    // (haven't seen any drawbacks from having it enabled)
+    if (props?.background !== false) {
+      config.modResults['com.apple.developer.healthkit.background-delivery'] =
+        true
+    }
+
+    return config
+  })
+
+/**
+ * @type {ConfigPlugin<InfoPlistConfig>}
+ */
+const withInfoPlistPlugin = (
+  config,
+  /**
+   * @type {{NSHealthShareUsageDescription: string | true, NSHealthUpdateUsageDescription: string | true} | undefined}
+   * */
+  props,
+) =>
+  withInfoPlist(config, (config) => {
+    config.modResults.NSHealthShareUsageDescription =
+      typeof props.NSHealthShareUsageDescription === 'string'
+        ? props.NSHealthShareUsageDescription
+        : `${config.name} wants to read your health data`
+
+    config.modResults.NSHealthUpdateUsageDescription =
+      typeof props.NSHealthUpdateUsageDescription === 'string'
+        ? props.NSHealthUpdateUsageDescription
+        : `${config.name} wants to update your health data`
+
+    return config
+  })
+
+const pkg = require('./package.json')
+
+/**
+ * @type {ConfigPlugin<AppPluginConfig>}
+ */
+const healthkitAppPlugin = (config, props) =>
+  withPlugins(config, [
+    [withEntitlementsPlugin, props],
+    [withInfoPlistPlugin, props],
+  ])
+
+/**
+ * @type {ConfigPlugin<AppPluginConfig>}
+ */
+module.exports = createRunOncePlugin(healthkitAppPlugin, pkg.name, pkg.version)

package/app.plugin.ts

@@ -0,0 +1,67 @@
+import {
+  type ConfigPlugin,
+  createRunOncePlugin,
+  withEntitlementsPlist,
+  withInfoPlist,
+  withPlugins,
+} from '@expo/config-plugins'
+
+import pkg from './package.json'
+
+// please note that the BackgroundConfig currently doesn't actually enable background delivery for any types, but you
+// can set it to false if you don't want the entitlement
+type BackgroundConfig = boolean
+
+type InfoPlistConfig = {
+  NSHealthShareUsageDescription?: string | true
+  NSHealthUpdateUsageDescription?: string | true
+}
+
+type AppPluginConfig = InfoPlistConfig & {
+  background?: BackgroundConfig
+}
+
+const withEntitlementsPlugin: ConfigPlugin<{
+  background?: BackgroundConfig
+}> = (config, props) => {
+  return withEntitlementsPlist(config, (configPlist) => {
+    configPlist.modResults['com.apple.developer.healthkit'] = true
+
+    // background is enabled by default, but possible to opt-out from
+    // (haven't seen any drawbacks from having it enabled)
+    if (props?.background !== false) {
+      configPlist.modResults[
+        'com.apple.developer.healthkit.background-delivery'
+      ] = true
+    }
+
+    return configPlist
+  })
+}
+
+const withInfoPlistPlugin: ConfigPlugin<InfoPlistConfig> = (config, props) => {
+  return withInfoPlist(config, (configPlist) => {
+    configPlist.modResults.NSHealthShareUsageDescription =
+      typeof props.NSHealthShareUsageDescription === 'string'
+        ? props.NSHealthShareUsageDescription
+        : `${config.name ?? pkg.name} wants to read your health data`
+
+    // Add description if it's not undefined and not explicitly false
+
+    configPlist.modResults.NSHealthUpdateUsageDescription =
+      typeof props.NSHealthUpdateUsageDescription === 'string'
+        ? props.NSHealthUpdateUsageDescription
+        : `${config.name ?? pkg.name} wants to update your health data`
+
+    return configPlist
+  })
+}
+
+const healthkitAppPlugin: ConfigPlugin<AppPluginConfig> = (config, props) => {
+  return withPlugins(config, [
+    [withEntitlementsPlugin, props],
+    [withInfoPlistPlugin, props],
+  ])
+}
+
+export default createRunOncePlugin(healthkitAppPlugin, pkg.name, pkg.version)

package/ios/CoreModule.swift

@@ -9,102 +9,99 @@ import NitroModules
 
 var store = HKHealthStore.init()
 
-var quantityTypeUnitCache = Dictionary<HKQuantityType, HKUnit>()
+var quantityTypeUnitCache = [HKQuantityType: HKUnit]()
 
 func getUnitToUse(unitOverride: String?, quantityType: HKQuantityType) async throws -> HKUnit {
     if let unitOverride = unitOverride {
         let unit = HKUnit(from: unitOverride)
-        
-        if(!quantityType.is(compatibleWith: unit)){
+
+        if !quantityType.is(compatibleWith: unit) {
             throw RuntimeError.error(withMessage: "[react-native-healthkit] Unit \(unitOverride) is incompatible with \(quantityType.identifier)")
         }
-        
+
         return unit
     }
-    
+
     if let preferredUnit = try await getPreferredUnitsInternal(quantityTypes: [quantityType]).first?.value {
         return preferredUnit
     }
-    
+
     throw RuntimeError.error(withMessage: "[react-native-healthkit] Must specify a unit for \(quantityType.identifier)")
 }
 
 func getPreferredUnitsInternal(quantityTypes: [HKQuantityType], forceUpdate: Bool? = false) async throws -> [HKQuantityType: HKUnit] {
-    
-    if(forceUpdate != true){
-        let itemsInCache = quantityTypeUnitCache.filter { (quantityType: HKQuantityType, unit: HKUnit) in
+
+    if forceUpdate != true {
+        let itemsInCache = quantityTypeUnitCache.filter { (quantityType: HKQuantityType, _: HKUnit) in
             return quantityTypes.contains(where: { $0 == quantityType })
         }
-        if(itemsInCache.count == quantityTypes.count){
+        if itemsInCache.count == quantityTypes.count {
             return itemsInCache
         }
     }
-    
-    
+
     return try await withCheckedThrowingContinuation { continuation in
         store.preferredUnits(for: Set(quantityTypes)) {
             (typePerUnits: [HKQuantityType: HKUnit], error: Error?) in
             if let error = error {
                 return continuation.resume(throwing: error)
             }
-            
+
             typePerUnits.forEach { (type: HKQuantityType, unit: HKUnit) in
                 quantityTypeUnitCache.updateValue(unit, forKey: type)
             }
-            
+
             return continuation.resume(returning: typePerUnits)
         }
     }
 }
 
-class CoreModule : HybridCoreModuleSpec {
-    func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Dictionary<String, Bool> {
-        var dict = Dictionary<String, Bool>()
-        
+class CoreModule: HybridCoreModuleSpec {
+    func areObjectTypesAvailable(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> [String: Bool] {
+        var dict = [String: Bool]()
+
         for objectTypeIdentifier in objectTypeIdentifiers {
             dict[objectTypeIdentifier.stringValue] = isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier)
         }
-        
+
         return dict
     }
-    
-    func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<Dictionary<String, Bool>> {
-        return Promise.resolved(withResult:  areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
+
+    func areObjectTypesAvailableAsync(objectTypeIdentifiers: [ObjectTypeIdentifier]) -> Promise<[String: Bool]> {
+        return Promise.resolved(withResult: areObjectTypesAvailable(objectTypeIdentifiers: objectTypeIdentifiers))
     }
-    
-    
-    
+
     func isObjectTypeAvailable(objectTypeIdentifier: ObjectTypeIdentifier) -> Bool {
         do {
-            let _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
+            _ = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
             return true
         } catch {
             return false
         }
     }
-    
+
     func isObjectTypeAvailableAsync(objectTypeIdentifier: ObjectTypeIdentifier) -> Promise<Bool> {
         return Promise.resolved(withResult: isObjectTypeAvailable(objectTypeIdentifier: objectTypeIdentifier))
     }
-    
+
     func authorizationStatusFor(
         type: ObjectTypeIdentifier
     ) throws -> AuthorizationStatus {
         let objectType = try objectTypeFrom(objectTypeIdentifier: type)
-        
+
         let authStatus = store.authorizationStatus(for: objectType)
-        
-        if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)){
+
+        if let authStatus = AuthorizationStatus(rawValue: Int32(authStatus.rawValue)) {
             return authStatus
         }
-        
+
         throw RuntimeError.error(withMessage: "[react-native-healthkit] got unrecognized AuthorizationStatus with value \(authStatus.rawValue)")
     }
-    
+
     func getRequestStatusForAuthorization(toShare: [SampleTypeIdentifierWriteable], toRead: [ObjectTypeIdentifier]) throws -> Promise<AuthorizationRequestStatus> {
         let toShare = sampleTypesFromArray(typeIdentifiersWriteable: toShare)
         let toRead = objectTypesFromArray(typeIdentifiers: toRead)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.getRequestStatusForAuthorization(toShare: toShare, read: toRead) { status, error in
@@ -116,17 +113,17 @@ class CoreModule : HybridCoreModuleSpec {
                         } else {
                             continuation.resume(throwing: RuntimeError.error(withMessage: "Unrecognized authStatus returned: \(status.rawValue)"))
                         }
-                        
+
                     }
                 }
             }
         }
     }
-    
+
     func requestAuthorization(toShare: [SampleTypeIdentifierWriteable], toRead: [ObjectTypeIdentifier]) throws -> Promise<Bool> {
         let share = sampleTypesFromArray(typeIdentifiersWriteable: toShare)
         let toRead = objectTypesFromArray(typeIdentifiers: toRead)
-        
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 store.requestAuthorization(toShare: share, read: toRead) { status, error in
@@ -139,10 +136,10 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func querySources(identifier: SampleTypeIdentifier) throws -> Promise<[HybridSourceProxySpec]> {
         let sampleType = try sampleTypeFrom(sampleTypeIdentifier: identifier)
-      
+
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
                 let query = HKSourceQuery(
@@ -153,26 +150,26 @@ class CoreModule : HybridCoreModuleSpec {
                         continuation.resume(throwing: error)
                         return
                     }
-                    
+
                     guard let sources = sources else {
                       return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response for sample type \(identifier.stringValue)"))
                     }
-                    
+
                     let serializedSources = sources.map { source -> SourceProxy in
-                      
+
                         return SourceProxy(
                             source: source
                         )
                     }
-                    
+
                     continuation.resume(returning: serializedSources)
                 }
-                
+
                 store.execute(query)
             }
         }
     }
-    
+
     func enableBackgroundDelivery(typeIdentifier: ObjectTypeIdentifier, updateFrequency: UpdateFrequency) throws -> Promise<Bool> {
         if let frequency = HKUpdateFrequency(rawValue: Int(updateFrequency.rawValue)) {
             let type = try objectTypeFrom(objectTypeIdentifier: typeIdentifier)
@@ -193,7 +190,7 @@ class CoreModule : HybridCoreModuleSpec {
             throw RuntimeError.error(withMessage: "Invalid update frequency value: \(updateFrequency)")
         }
     }
-    
+
     func disableBackgroundDelivery(
         typeIdentifier: ObjectTypeIdentifier
     ) throws -> Promise<Bool> {
@@ -211,7 +208,7 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func disableAllBackgroundDelivery() throws -> Promise<Bool> {
         return Promise.async {
             try await withCheckedThrowingContinuation { continuation in
@@ -224,64 +221,65 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func unsubscribeQueryAsync(queryId: String) throws -> Promise<Bool> {
         let result = try self.unsubscribeQuery(queryId: queryId)
-        
+
         return Promise.resolved(withResult: result)
     }
-    
+
     func isHealthDataAvailableAsync() -> Promise<Bool> {
         return Promise.resolved(withResult: HKHealthStore.isHealthDataAvailable())
     }
-    
+
     func isProtectedDataAvailableAsync() -> Promise<Bool> {
         return Promise.resolved(withResult: UIApplication.shared.isProtectedDataAvailable)
     }
-    
+
     func isHealthDataAvailable() throws -> Bool {
         return HKHealthStore.isHealthDataAvailable()
     }
-    
+
     func isProtectedDataAvailable() throws -> Bool {
         return UIApplication.shared.isProtectedDataAvailable
     }
-    
+
     func getPreferredUnits(identifiers: [QuantityTypeIdentifier], forceUpdate: Bool?) throws -> Promise<[IdentifierWithUnit]> {
         return Promise.async {
-            
+
             let quantityTypes = identifiers.compactMap { identifier in
                 do {
                     let quantityType = try initializeQuantityType(identifier.stringValue)
+
                     return quantityType
                 } catch {
                     print(error.localizedDescription)
                     return nil
                 }
             }
-            
+
             let typePerUnits = try await getPreferredUnitsInternal(quantityTypes: quantityTypes, forceUpdate: forceUpdate)
-            
+
             let dic = typePerUnits.map { typePerUnit in
                 return IdentifierWithUnit(
                     typeIdentifier: typePerUnit.key.identifier,
                     unit: typePerUnit.value.unitString
                 )
             }
-            
+
             return dic
         }
     }
-    
+
     var _runningQueries: [String: HKQuery] = [:]
-    
+
     func deleteObjects(objectTypeIdentifier: ObjectTypeIdentifier, filter: FilterForSamples) throws -> Promise<Double> {
         let predicate = try createPredicateForSamples(filter: filter)
         let of = try objectTypeFrom(objectTypeIdentifier: objectTypeIdentifier)
-        
+
         return Promise.async {
             return try await withCheckedThrowingContinuation { continuation in
-                store.deleteObjects(of: of, predicate: predicate) { (success, count, error) in
+                store.deleteObjects(of: of, predicate: predicate) { (_, count, error) in
                     if let error = error {
                         continuation.resume(throwing: error)
                     } else {
@@ -291,21 +289,21 @@ class CoreModule : HybridCoreModuleSpec {
             }
         }
     }
-    
+
     func subscribeToObserverQuery(
         typeIdentifier: SampleTypeIdentifier,
         callback: @escaping (OnChangeCallbackArgs) -> Void
     ) throws -> String {
         let sampleType = try sampleTypeFrom(sampleTypeIdentifier: typeIdentifier)
-        
+
         let predicate = HKQuery.predicateForSamples(
             withStart: Date.init(),
             end: nil,
             options: HKQueryOptions.strictStartDate
         )
-        
+
         let queryId = UUID().uuidString
-        
+
         func responder(
             query: HKObserverQuery,
             handler: @escaping HKObserverQueryCompletionHandler,
@@ -316,42 +314,42 @@ class CoreModule : HybridCoreModuleSpec {
                 handler()
             }
         }
-        
+
         let query = HKObserverQuery(
             sampleType: sampleType,
             predicate: predicate
         ) {
             (query: HKObserverQuery, handler: @escaping HKObserverQueryCompletionHandler, error: Error?)
             in
-            
+
             return responder(query: query, handler: handler, error: error)
-            
+
         }
-        
+
         store.execute(query)
-        
+
         self._runningQueries.updateValue(query, forKey: queryId)
-        
-        //resolve(queryId)
-        
+
+        // resolve(queryId)
+
         return queryId
     }
-    
+
     func unsubscribeQuery(queryId: String) throws -> Bool {
         guard let query = self._runningQueries[queryId] else {
             throw RuntimeError.error(withMessage: "Query with id \(queryId) not found")
         }
-        
+
         store.stop(query)
-        
+
         self._runningQueries.removeValue(forKey: queryId)
-        
+
         return true
     }
-    
+
     func unsubscribeQueriesAsync(queryIds: [String]) throws -> Promise<Double> {
         let successCount = self.unsubscribeQueries(queryIds: queryIds)
-        
+
         return Promise.resolved(withResult: successCount)
     }
 
@@ -359,17 +357,17 @@ class CoreModule : HybridCoreModuleSpec {
         let successCounts = queryIds.map { queryId in
             if let query = self._runningQueries[queryId] {
                 store.stop(query)
-                
+
                 self._runningQueries.removeValue(forKey: queryId)
-                
+
                 return true
             }
-            
+
             print("Query with id \(queryId) not found, skipping unsubscribe")
-            
+
             return false
         }
-        
+
         return Double(successCounts.filter { $0 }.count)
     }
 

package/ios/Helpers.swift

@@ -136,27 +136,6 @@ func createUUIDsPredicate(uuidsWrapper: PredicateWithUUIDs) -> NSPredicate {
     return HKQuery.predicateForObjects(with: Set(uuids))
 }
 
-func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout?) throws -> NSPredicate? {
-    if let filter = filter {
-        switch filter {
-            case .first(let uuidWrapper):
-                return HKQuery.predicateForObject(with: try initializeUUID(uuidWrapper.uuid))
-            case .second(let uuidsWrapper):
-                return createUUIDsPredicate(uuidsWrapper: uuidsWrapper)
-            case .third(let metadataKey):
-                return HKQuery.predicateForObjects(withMetadataKey: metadataKey.withMetadataKey)
-            case .fourth(let dateFilter):
-                return createDatePredicate(dateFilter: dateFilter)
-            case .fifth(let w):
-              if let w = w.workout as? WorkoutProxy {
-                return w.workoutPredicate
-              }
-              throw RuntimeError.error(withMessage: "[react-native-healthkit] Failed to initialize workout for filter")
-        }
-    }
-    return nil
-}
-
 func createPredicate(filter: Variant_PredicateWithUUID_PredicateWithUUIDs_PredicateWithMetadataKey_PredicateWithStartAndEnd_PredicateFromWorkout_FilterForSamplesAnd_FilterForSamplesOr?) throws -> NSPredicate? {
     if let filter = filter {
         switch filter {

package/lib/commonjs/index.ios.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -31,6 +45,7 @@ const getMostRecentWorkout_1 = __importDefault(require("./utils/getMostRecentWor
 exports.getMostRecentWorkout = getMostRecentWorkout_1.default;
 const getPreferredUnit_1 = __importDefault(require("./utils/getPreferredUnit"));
 exports.getPreferredUnit = getPreferredUnit_1.default;
+__exportStar(require("./types"), exports);
 const currentMajorVersionIOS = react_native_1.Platform.OS === 'ios' ? Number.parseInt(react_native_1.Platform.Version, 10) : 0;
 // Named exports - all functions bound to their respective modules
 exports.authorizationStatusFor = modules_1.Core.authorizationStatusFor.bind(modules_1.Core);

package/lib/commonjs/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBiologicalSexAsync = exports.useStatisticsForQuantity = exports.useSources = exports.useIsHealthDataAvailable = exports.useHealthkitAuthorization = exports.useSubscribeToChanges = exports.useMostRecentWorkout = exports.useMostRecentQuantitySample = exports.getPreferredUnit = exports.getMostRecentWorkout = exports.getMostRecentQuantitySample = exports.saveStateOfMindSample = exports.queryStateOfMindSamples = exports.startWatchApp = exports.saveWorkoutSample = exports.queryWorkoutSamplesWithAnchor = exports.queryWorkoutSamples = exports.queryHeartbeatSeriesSamplesWithAnchor = exports.queryHeartbeatSeriesSamples = exports.saveCorrelationSample = exports.queryCorrelationSamples = exports.saveCategorySample = exports.isQuantityCompatibleWithUnit = exports.saveQuantitySample = exports.queryStatisticsCollectionForQuantity = exports.queryStatisticsForQuantity = exports.queryQuantitySamplesWithAnchor = exports.queryQuantitySamples = exports.getWheelchairUse = exports.getFitzpatrickSkinType = exports.getDateOfBirth = exports.getBloodType = exports.getBiologicalSex = exports.areObjectTypesAvailableAsync = exports.areObjectTypesAvailable = exports.isObjectTypeAvailableAsync = exports.isObjectTypeAvailable = exports.isProtectedDataAvailable = exports.subscribeToChanges = exports.deleteObjects = exports.requestAuthorization = exports.querySources = exports.isHealthDataAvailableAsync = exports.isHealthDataAvailable = exports.getRequestStatusForAuthorization = exports.getPreferredUnits = exports.enableBackgroundDelivery = exports.disableBackgroundDelivery = exports.disableAllBackgroundDelivery = exports.authorizationStatusFor = void 0;
 exports.unsubscribeQueries = exports.getWheelchairUseAsync = exports.getFitzpatrickSkinTypeAsync = exports.getDateOfBirthAsync = exports.getBloodTypeAsync = void 0;
@@ -9,6 +23,7 @@ exports.useMostRecentCategorySample = useMostRecentCategorySample;
 const react_native_1 = require("react-native");
 const Auth_1 = require("./types/Auth");
 const Characteristics_1 = require("./types/Characteristics");
+__exportStar(require("./types"), exports);
 const notAvailableError = `[@kingstinct/react-native-healthkit] Platform "${react_native_1.Platform.OS}" not supported. HealthKit is only available on iOS.`;
 let hasWarned = false;
 // @ts-ignore

package/lib/commonjs/types/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./Background"), exports);
+__exportStar(require("./CategoryType"), exports);
+__exportStar(require("./CategoryTypeIdentifier"), exports);
+__exportStar(require("./Characteristics"), exports);
+__exportStar(require("./Constants"), exports);
+__exportStar(require("./CorrelationType"), exports);
+__exportStar(require("./Device"), exports);
+__exportStar(require("./HeartbeatSeries"), exports);
+__exportStar(require("./QuantitySample"), exports);
+__exportStar(require("./QuantityType"), exports);
+__exportStar(require("./QuantityTypeIdentifier"), exports);
+__exportStar(require("./QueryOptions"), exports);
+__exportStar(require("./Shared"), exports);
+__exportStar(require("./Source"), exports);
+__exportStar(require("./StateOfMind"), exports);
+__exportStar(require("./Subscriptions"), exports);
+__exportStar(require("./Units"), exports);
+__exportStar(require("./WeatherCondition"), exports);
+__exportStar(require("./WorkoutKit"), exports);
+__exportStar(require("./Workouts"), exports);