@kingstinct/react-native-healthkit 4.2.0 → 4.4.1

package/src/index.ios.tsx

@@ -1,21 +1,29 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useCallback, useEffect, useState } from 'react'
+
 import Native, {
   EventEmitter,
-  HKCategorySampleRaw,
+  HKQuantityTypeIdentifier,
+  HKUnit,
   HKCategoryTypeIdentifier,
+} from './native-types'
+
+import type {
+  HKSampleTypeIdentifier,
+  HKCategorySampleRaw,
   HKCategoryValueForIdentifier,
   HKCharacteristicTypeIdentifier,
   HKCorrelationRaw,
   HKCorrelationTypeIdentifier,
   HKQuantitySampleRaw,
-  HKQuantityTypeIdentifier,
-  HKSampleTypeIdentifier,
-  HKUnit,
   HKUnitSI,
   HKUnitSIPrefix,
   HKWorkoutRaw,
   MetadataMapperForCategoryIdentifier,
-} from './native-types';
+  ReadPermissions,
+  WritePermissions,
+  HealthkitAuthorization,
+  HKAuthorizationRequestStatus,
+} from './native-types'
 import type {
   GenericQueryOptions,
   GetMostRecentCategorySampleFn,
@@ -23,6 +31,7 @@ import type {
   GetMostRecentWorkoutFn,
   GetPreferredUnitFn,
   GetPreferredUnitsFn,
+  GetWorkoutRoutesFn,
   HKCategorySample,
   HKCorrelation,
   HKQuantitySample,
@@ -37,76 +46,74 @@ import type {
   SaveQuantitySampleFn,
   SaveWorkoutSampleFn,
   SubscribeToChangesFn,
-} from './types';
+} from './types'
+import type { ValueOf } from 'type-fest'
 
 const getPreferredUnit: GetPreferredUnitFn = async (type) => {
-  const [unit] = await getPreferredUnits([type]);
-  return unit;
-};
+  const [unit] = await getPreferredUnits([type])
+  return unit
+}
 
 const ensureUnit = async <TUnit extends HKUnit>(
   type: HKQuantityTypeIdentifier,
-  providedUnit?: TUnit
+  providedUnit?: TUnit,
 ) => {
   if (providedUnit) {
-    return providedUnit;
+    return providedUnit
   }
-  const unit = await Native.getPreferredUnits([type]);
-  return unit[type] as TUnit;
-};
+  const unit = await Native.getPreferredUnits([type])
+  return unit[type] as TUnit
+}
 
 function deserializeSample<
   TIdentifier extends HKQuantityTypeIdentifier,
   TUnit extends HKUnit
 >(
-  sample: HKQuantitySampleRaw<TIdentifier, TUnit>
+  sample: HKQuantitySampleRaw<TIdentifier, TUnit>,
 ): HKQuantitySample<TIdentifier, TUnit> {
   return {
     ...sample,
     startDate: new Date(sample.startDate),
     endDate: new Date(sample.endDate),
-  };
+  }
 }
 
 function deserializeWorkout<TEnergy extends HKUnit, TDistance extends HKUnit>(
-  sample: HKWorkoutRaw<TEnergy, TDistance>
+  sample: HKWorkoutRaw<TEnergy, TDistance>,
 ): HKWorkout<TEnergy, TDistance> {
   return {
     ...sample,
     startDate: new Date(sample.startDate),
     endDate: new Date(sample.endDate),
-  };
+  }
 }
 
 const deserializCategorySample = <T extends HKCategoryTypeIdentifier>(
-  sample: HKCategorySampleRaw<T>
-): HKCategorySample<T> => {
-  return {
-    ...sample,
-    startDate: new Date(sample.startDate),
-    endDate: new Date(sample.endDate),
-  };
-};
+  sample: HKCategorySampleRaw<T>,
+): HKCategorySample<T> => ({
+  ...sample,
+  startDate: new Date(sample.startDate),
+  endDate: new Date(sample.endDate),
+})
 
-const serializeDate = (date?: Date | null): string => {
-  return date ? date.toISOString() : new Date(0).toISOString();
-};
+const serializeDate = (date?: Date | null): string => (date ? date.toISOString() : new Date(0).toISOString())
 
 const prepareOptions = (options: GenericQueryOptions) => {
-  const limit =
-    !options.limit || options.limit === Infinity ? 0 : options.limit;
-  const ascending = options.ascending ?? limit === 0;
-  const from = serializeDate(options.from);
-  const to = serializeDate(options.to);
-  return { limit, ascending, from, to };
-};
+  const limit = !options.limit || options.limit === Infinity ? 0 : options.limit
+  const ascending = options.ascending ?? limit === 0
+  const from = serializeDate(options.from)
+  const to = serializeDate(options.to)
+  return {
+    limit, ascending, from, to,
+  }
+}
 
 const queryQuantitySamples: QueryQuantitySamplesFn = async (
   identifier,
-  options
+  options,
 ) => {
-  const unit = await ensureUnit(identifier, options.unit);
-  const opts = prepareOptions(options);
+  const unit = await ensureUnit(identifier, options.unit)
+  const opts = prepareOptions(options)
 
   const quantitySamples = await Native.queryQuantitySamples(
     identifier,
@@ -114,121 +121,155 @@ const queryQuantitySamples: QueryQuantitySamplesFn = async (
     opts.from,
     opts.to,
     opts.limit,
-    opts.ascending
-  );
+    opts.ascending,
+  )
+
+  return quantitySamples.map(deserializeSample)
+}
 
-  return quantitySamples.map(deserializeSample);
-};
+async function getPreferredUnitsTyped<
+  TEnergy extends HKUnit,
+  TDistance extends HKUnit
+>(options?: { readonly energyUnit?: TEnergy; readonly distanceUnit?: TDistance }) {
+  let energyUnit = options?.energyUnit
+  let distanceUnit = options?.distanceUnit
+  if (!energyUnit || !distanceUnit) {
+    const units = await Native.getPreferredUnits([
+      HKQuantityTypeIdentifier.distanceWalkingRunning,
+      HKQuantityTypeIdentifier.activeEnergyBurned,
+    ])
+    if (!energyUnit) {
+      energyUnit = units[HKQuantityTypeIdentifier.distanceWalkingRunning] as
+        | TEnergy
+        | undefined
+    }
+    if (!distanceUnit) {
+      distanceUnit = units[HKQuantityTypeIdentifier.activeEnergyBurned] as
+        | TDistance
+        | undefined
+    }
+  }
+  if (!energyUnit) {
+    energyUnit = HKUnit.Kilocalories as TEnergy
+  }
+  if (!distanceUnit) {
+    distanceUnit = HKUnit.Meters as TDistance
+  }
+  return { energyUnit, distanceUnit }
+}
 
 const subscribeToChanges: SubscribeToChangesFn = async (
   identifier,
-  callback
+  callback,
 ) => {
   const subscription = EventEmitter.addListener(
     'onChange',
     ({ typeIdentifier }) => {
       if (typeIdentifier === identifier) {
-        callback();
+        callback()
       }
-    }
-  );
+    },
+  )
 
   const queryId = await Native.subscribeToObserverQuery(identifier).catch(
-    (error) => {
-      subscription.remove();
-      return Promise.reject(error);
-    }
-  );
-
-  return () => {
-    subscription.remove();
-    return Native.unsubscribeQuery(queryId);
-  };
-};
+    async (error) => {
+      subscription.remove()
+      return Promise.reject(error)
+    },
+  )
+
+  return async () => {
+    subscription.remove()
+    return Native.unsubscribeQuery(queryId)
+  }
+}
 
 const getMostRecentQuantitySample: GetMostRecentQuantitySampleFn = async (
   identifier,
-  unit
+  unit,
 ) => {
   const samples = await queryQuantitySamples(identifier, {
     limit: 1,
-    unit: unit,
-  });
-  return samples[0];
-};
+    unit,
+  })
+  return samples[0]
+}
 
 function useMostRecentWorkout<
   TEnergy extends HKUnit,
   TDistance extends HKUnit
->(options?: { energyUnit?: TEnergy; distanceUnit?: TDistance }) {
+>(options?: { readonly energyUnit?: TEnergy; readonly distanceUnit?: TDistance }) {
   const [workout, setWorkout] = useState<HKWorkout<TEnergy, TDistance> | null>(
-    null
-  );
+    null,
+  )
   useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined;
+    let cancelSubscription: (() => Promise<boolean>) | undefined
 
     const init = async () => {
       const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(
-        options
-      );
+        options,
+      )
 
       cancelSubscription = await subscribeToChanges(
         'HKWorkoutTypeIdentifier',
-        () => {
-          getMostRecentWorkout({ energyUnit, distanceUnit }).then(setWorkout);
-        }
-      );
-    };
-    init();
+        async () => {
+          const w = await getMostRecentWorkout({ energyUnit, distanceUnit })
+          setWorkout(w)
+        },
+      )
+    }
+    void init()
     return () => {
-      cancelSubscription && cancelSubscription();
-    };
-  }, [options]);
-  return workout;
+      void cancelSubscription?.()
+    }
+  }, [options])
+  return workout
 }
 
 const getMostRecentCategorySample: GetMostRecentCategorySampleFn = async (
-  identifier
+  identifier,
 ) => {
   const samples = await queryCategorySamples(identifier, {
     limit: 1,
     ascending: false,
-  });
-
-  return samples[0];
-};
-
-function useMostRecentCategorySample<
-  TCategory extends HKCategoryTypeIdentifier
->(identifier: TCategory) {
-  const [category, setCategory] = useState<HKCategorySample<TCategory> | null>(
-    null
-  );
-  const updater = useCallback(() => {
-    getMostRecentCategorySample(identifier).then(setCategory);
-  }, [identifier]);
+  })
 
-  useSubscribeToChanges(identifier, updater);
-
-  return category;
+  return samples[0]
 }
 
-function useSubscribeToChanges<TIdentifier extends HKSampleTypeIdentifier>(
+function useSubscribeToChanges<TIdentifier extends ValueOf<typeof HKSampleTypeIdentifier>>(
   identifier: TIdentifier,
-  onChange: () => void
+  onChange: () => void,
 ): void {
   useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined;
+    let cancelSubscription: (() => Promise<boolean>) | undefined
 
     const init = async () => {
-      cancelSubscription = await subscribeToChanges(identifier, onChange);
-    };
-    init();
+      cancelSubscription = await subscribeToChanges(identifier, onChange)
+    }
+    void init()
 
     return () => {
-      cancelSubscription && cancelSubscription();
-    };
-  }, [identifier, onChange]);
+      void cancelSubscription?.()
+    }
+  }, [identifier, onChange])
+}
+
+useSubscribeToChanges(HKCategoryTypeIdentifier.appleStandHour, () => {})
+
+function useMostRecentCategorySample<
+  TCategory extends HKCategoryTypeIdentifier
+>(identifier: TCategory) {
+  const [category, setCategory] = useState<HKCategorySample<TCategory> | null>(
+    null,
+  )
+  const updater = useCallback(() => {
+    void getMostRecentCategorySample(identifier).then(setCategory)
+  }, [identifier])
+
+  useSubscribeToChanges(identifier, updater)
+
+  return category
 }
 
 function useMostRecentQuantitySample<
@@ -236,41 +277,40 @@ function useMostRecentQuantitySample<
   TUnit extends HKUnit = HKUnit
 >(identifier: TIdentifier, unit?: TUnit) {
   const [lastSample, setLastSample] = useState<HKQuantitySample<
-    TIdentifier,
-    TUnit
-  > | null>(null);
+  TIdentifier,
+  TUnit
+  > | null>(null)
 
   useEffect(() => {
-    let cancelSubscription: (() => Promise<boolean>) | undefined;
+    let cancelSubscription: (() => Promise<boolean>) | undefined
 
     const init = async () => {
-      const actualUnit = await ensureUnit(identifier, unit);
+      const actualUnit = await ensureUnit(identifier, unit)
 
-      cancelSubscription = await subscribeToChanges(identifier, () => {
-        getMostRecentQuantitySample(identifier, actualUnit).then((value) => {
-          setLastSample(value);
-        });
-      });
-    };
-    init();
+      cancelSubscription = await subscribeToChanges(identifier, async () => {
+        const value = await getMostRecentQuantitySample(identifier, actualUnit)
+        setLastSample(value)
+      })
+    }
+    void init()
 
     return () => {
-      cancelSubscription && cancelSubscription();
-    };
-  }, [identifier, unit]);
+      void cancelSubscription?.()
+    }
+  }, [identifier, unit])
 
-  return lastSample;
+  return lastSample
 }
 
-const saveQuantitySample: SaveQuantitySampleFn = (
+const saveQuantitySample: SaveQuantitySampleFn = async (
   identifier,
   unit,
   value,
-  options
+  options,
 ) => {
-  const start = options?.start || options?.end || new Date();
-  const end = options?.end || options?.start || new Date();
-  const metadata = options?.metadata || {};
+  const start = options?.start || options?.end || new Date()
+  const end = options?.end || options?.start || new Date()
+  const metadata = options?.metadata || {}
 
   return Native.saveQuantitySample(
     identifier,
@@ -278,131 +318,91 @@ const saveQuantitySample: SaveQuantitySampleFn = (
     value,
     start.toISOString(),
     end.toISOString(),
-    metadata
-  );
-};
+    metadata,
+  )
+}
 
 const queryStatisticsForQuantity: QueryStatisticsForQuantityFn = async (
   identifier,
   options,
   from,
   to,
-  unit
+  unit,
 ) => {
-  const actualUnit = await ensureUnit(identifier, unit);
-  const toDate = to || new Date();
-  const { mostRecentQuantityDateInterval, ...rawResponse } =
-    await Native.queryStatisticsForQuantity(
-      identifier,
-      actualUnit,
-      from.toISOString(),
-      toDate.toISOString(),
-      options
-    );
+  const actualUnit = await ensureUnit(identifier, unit)
+  const toDate = to || new Date()
+  const { mostRecentQuantityDateInterval, ...rawResponse } = await Native.queryStatisticsForQuantity(
+    identifier,
+    actualUnit,
+    from.toISOString(),
+    toDate.toISOString(),
+    options,
+  )
 
   const response = {
     ...rawResponse,
     ...(mostRecentQuantityDateInterval
       ? {
-          mostRecentQuantityDateInterval: {
-            from: new Date(mostRecentQuantityDateInterval.from),
-            to: new Date(mostRecentQuantityDateInterval.to),
-          },
-        }
+        mostRecentQuantityDateInterval: {
+          from: new Date(mostRecentQuantityDateInterval.from),
+          to: new Date(mostRecentQuantityDateInterval.to),
+        },
+      }
       : {}),
-  };
+  }
 
-  return response;
-};
+  return response
+}
 
-const requestAuthorization = (
-  read: (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[],
-  write: HKSampleTypeIdentifier[] = []
+const requestAuthorization = async (
+  read: readonly ValueOf<typeof HealthkitAuthorization>[],
+  write: readonly ValueOf<typeof HKSampleTypeIdentifier>[] = [],
 ): Promise<boolean> => {
-  const readPermissions = read.reduce((obj, cur) => {
-    return { ...obj, [cur]: true };
-  }, {});
+  const readPermissions = read.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as ReadPermissions)
 
-  const writePermissions = write.reduce((obj, cur) => {
-    return { ...obj, [cur]: true };
-  }, {});
+  const writePermissions = write.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as WritePermissions)
 
-  return Native.requestAuthorization(writePermissions, readPermissions);
-};
+  return Native.requestAuthorization(writePermissions, readPermissions)
+}
 
 const getDateOfBirth = async () => {
-  const dateOfBirth = await Native.getDateOfBirth();
-  return new Date(dateOfBirth);
-};
+  const dateOfBirth = await Native.getDateOfBirth()
+  return new Date(dateOfBirth)
+}
 
-const getRequestStatusForAuthorization = (
-  read: (HKCharacteristicTypeIdentifier | HKSampleTypeIdentifier)[],
-  write: HKSampleTypeIdentifier[] = []
+const getRequestStatusForAuthorization = async (
+  read: readonly (HKCharacteristicTypeIdentifier | ValueOf<typeof HKSampleTypeIdentifier>)[],
+  write: readonly (ValueOf<typeof HKSampleTypeIdentifier>)[] = [],
 ) => {
-  const readPermissions = read.reduce((obj, cur) => {
-    return { ...obj, [cur]: true };
-  }, {});
+  const readPermissions = read.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as ReadPermissions)
 
-  const writePermissions = write.reduce((obj, cur) => {
-    return { ...obj, [cur]: true };
-  }, {});
+  const writePermissions = write.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as WritePermissions)
 
   return Native.getRequestStatusForAuthorization(
     writePermissions,
-    readPermissions
-  );
-};
+    readPermissions,
+  )
+}
 
 const queryCategorySamples: QueryCategorySamplesFn = async (
   identifier,
-  options
+  options,
 ) => {
-  const opts = prepareOptions(options);
+  const opts = prepareOptions(options)
   const results = await Native.queryCategorySamples(
     identifier,
     opts.from,
     opts.to,
     opts.limit,
-    opts.ascending
-  );
+    opts.ascending,
+  )
 
-  return results.map(deserializCategorySample);
-};
-
-async function getPreferredUnitsTyped<
-  TEnergy extends HKUnit,
-  TDistance extends HKUnit
->(options?: { energyUnit?: TEnergy; distanceUnit?: TDistance }) {
-  let energyUnit = options?.energyUnit;
-  let distanceUnit = options?.distanceUnit;
-  if (!energyUnit || !distanceUnit) {
-    const units = await Native.getPreferredUnits([
-      HKQuantityTypeIdentifier.distanceWalkingRunning,
-      HKQuantityTypeIdentifier.activeEnergyBurned,
-    ]);
-    if (!energyUnit) {
-      energyUnit = units[HKQuantityTypeIdentifier.distanceWalkingRunning] as
-        | TEnergy
-        | undefined;
-    }
-    if (!distanceUnit) {
-      distanceUnit = units[HKQuantityTypeIdentifier.activeEnergyBurned] as
-        | TDistance
-        | undefined;
-    }
-  }
-  if (!energyUnit) {
-    energyUnit = HKUnit.Kilocalories as TEnergy;
-  }
-  if (!distanceUnit) {
-    distanceUnit = HKUnit.Meters as TDistance;
-  }
-  return { energyUnit, distanceUnit };
+  return results.map(deserializCategorySample)
 }
 
 const queryWorkouts: QueryWorkoutsFn = async (options) => {
-  const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(options);
-  const opts = prepareOptions(options);
+  const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(options)
+  const opts = prepareOptions(options)
 
   const workouts = await Native.queryWorkoutSamples(
     energyUnit,
@@ -410,11 +410,11 @@ const queryWorkouts: QueryWorkoutsFn = async (options) => {
     opts.from,
     opts.to,
     opts.limit,
-    opts.ascending
-  );
+    opts.ascending,
+  )
 
-  return workouts.map(deserializeWorkout);
-};
+  return workouts.map(deserializeWorkout)
+}
 
 const getMostRecentWorkout: GetMostRecentWorkoutFn = async (options) => {
   const workouts = await queryWorkouts({
@@ -422,41 +422,39 @@ const getMostRecentWorkout: GetMostRecentWorkoutFn = async (options) => {
     ascending: false,
     energyUnit: options?.energyUnit,
     distanceUnit: options?.distanceUnit,
-  });
+  })
 
-  return workouts[0];
-};
+  return workouts[0]
+}
 
-function saveCategorySample<T extends HKCategoryTypeIdentifier>(
+async function saveCategorySample<T extends HKCategoryTypeIdentifier>(
   identifier: T,
   value: HKCategoryValueForIdentifier<T>,
   options?: {
-    start?: Date;
-    end?: Date;
-    metadata?: MetadataMapperForCategoryIdentifier<T>;
-  }
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForCategoryIdentifier<T>;
+  },
 ) {
-  const start = options?.start || options?.end || new Date();
-  const end = options?.end || options?.start || new Date();
-  const metadata = options?.metadata || {};
+  const start = options?.start || options?.end || new Date()
+  const end = options?.end || options?.start || new Date()
+  const metadata = options?.metadata || {}
 
   return Native.saveCategorySample(
     identifier,
     value,
     start.toISOString(),
     end.toISOString(),
-    metadata || {}
-  );
+    metadata || {},
+  )
 }
 
 const getPreferredUnits: GetPreferredUnitsFn = async (identifiers) => {
-  const units = await Native.getPreferredUnits(identifiers);
-  return identifiers.map((i) => units[i]);
-};
+  const units = await Native.getPreferredUnits(identifiers)
+  return identifiers.map((i) => units[i])
+}
 
-const buildUnitWithPrefix = (prefix: HKUnitSIPrefix, unit: HKUnitSI) => {
-  return `${prefix}${unit}` as HKUnit;
-};
+const buildUnitWithPrefix = (prefix: HKUnitSIPrefix, unit: HKUnitSI) => `${prefix}${unit}` as HKUnit
 
 function deserializeCorrelation<
   TIdentifier extends HKCorrelationTypeIdentifier
@@ -464,75 +462,78 @@ function deserializeCorrelation<
   return {
     ...s,
     objects: s.objects.map((o) => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
       if (o.quantity !== undefined) {
-        return deserializeSample(o as HKQuantitySampleRaw);
+        return deserializeSample(o as HKQuantitySampleRaw)
       }
 
-      return deserializCategorySample(o as HKCategorySampleRaw);
+      return deserializCategorySample(o as HKCategorySampleRaw)
     }),
     endDate: new Date(s.endDate),
     startDate: new Date(s.startDate),
-  };
+  }
 }
 
 function ensureMetadata<TMetadata>(metadata?: TMetadata) {
-  return metadata || ({} as TMetadata);
+  return metadata || ({} as TMetadata)
 }
 
 const queryCorrelationSamples: QueryCorrelationSamplesFn = async (
   typeIdentifier,
-  options
+  options,
 ) => {
-  const opts = prepareOptions(options);
+  const opts = prepareOptions(options)
   const correlations = await Native.queryCorrelationSamples(
     typeIdentifier,
     opts.from,
-    opts.to
-  );
+    opts.to,
+  )
 
-  return correlations.map(deserializeCorrelation);
-};
+  return correlations.map(deserializeCorrelation)
+}
 
 const saveCorrelationSample: SaveCorrelationSampleFn = async (
   typeIdentifier,
   samples,
-  options
+  options,
 ) => {
-  const start = (options?.start || new Date()).toISOString();
-  const end = (options?.end || new Date()).toISOString();
+  const start = (options?.start || new Date()).toISOString()
+  const end = (options?.end || new Date()).toISOString()
 
   return Native.saveCorrelationSample(
     typeIdentifier,
     samples,
     start,
     end,
-    ensureMetadata(options?.metadata)
-  );
-};
+    ensureMetadata(options?.metadata),
+  )
+}
 
-const saveWorkoutSample: SaveWorkoutSampleFn = (
+const saveWorkoutSample: SaveWorkoutSampleFn = async (
   typeIdentifier,
   quantities,
   _start,
-  options
+  options,
 ) => {
-  const start = _start.toISOString();
-  const end = (options?.end || new Date()).toISOString();
+  const start = _start.toISOString()
+  const end = (options?.end || new Date()).toISOString()
 
   return Native.saveWorkoutSample(
     typeIdentifier,
     quantities,
     start,
     end,
-    ensureMetadata(options?.metadata)
-  );
-};
+    ensureMetadata(options?.metadata),
+  )
+}
+
+const getWorkoutRoutes: GetWorkoutRoutesFn = async (workoutUUID: string) => Native.getWorkoutRoutes(workoutUUID)
 
 const Healthkit: ReactNativeHealthkit = {
-  authorizationStatusFor: Native.authorizationStatusFor,
+  authorizationStatusFor: Native.authorizationStatusFor.bind(Native),
 
-  isHealthDataAvailable: Native.isHealthDataAvailable,
+  isHealthDataAvailable: Native.isHealthDataAvailable.bind(Native),
 
   buildUnitWithPrefix,
 
@@ -541,10 +542,10 @@ const Healthkit: ReactNativeHealthkit = {
   enableBackgroundDelivery: Native.enableBackgroundDelivery,
 
   // simple convenience getters
-  getBiologicalSex: Native.getBiologicalSex,
-  getFitzpatrickSkinType: Native.getFitzpatrickSkinType,
+  getBiologicalSex: Native.getBiologicalSex.bind(Native),
+  getFitzpatrickSkinType: Native.getFitzpatrickSkinType.bind(Native),
   getWheelchairUse: Native.getWheelchairUse,
-  getBloodType: Native.getBloodType,
+  getBloodType: Native.getBloodType.bind(Native),
   getDateOfBirth,
 
   getMostRecentQuantitySample,
@@ -555,6 +556,8 @@ const Healthkit: ReactNativeHealthkit = {
   getPreferredUnits,
   getRequestStatusForAuthorization,
 
+  getWorkoutRoutes,
+
   // query methods
   queryCategorySamples,
   queryCorrelationSamples,
@@ -580,9 +583,40 @@ const Healthkit: ReactNativeHealthkit = {
   useMostRecentWorkout,
 
   useSubscribeToChanges,
-};
 
-export * from './types';
-export * from './native-types';
+  useIsHealthDataAvailable: () => {
+    const [isAvailable, setIsAvailable] = useState<boolean | null>(null)
+    useEffect(() => {
+      const init = async () => {
+        const res = await Native.isHealthDataAvailable()
+        setIsAvailable(res)
+      }
+      void init()
+    }, [])
+    return isAvailable
+  },
+  useHealthkitAuthorization: (read, write) => {
+    const [status, setStatus] = useState<HKAuthorizationRequestStatus | null>(null)
+    const refreshAuthStatus = useCallback(async () => {
+      const auth = await getRequestStatusForAuthorization(read, write)
+      setStatus(auth)
+      return auth
+    }, [])
+
+    const request = useCallback(async () => {
+      await requestAuthorization(read, write)
+      return refreshAuthStatus()
+    }, [])
+
+    useEffect(() => {
+      void refreshAuthStatus()
+    }, [])
+
+    return [status, request]
+  },
+}
+
+export * from './native-types'
+export * from './types'
 
-export default Healthkit;
+export default Healthkit