@kingstinct/react-native-healthkit 4.2.0 → 4.3.0

package/lib/example/App.js

@@ -0,0 +1,197 @@
+/* eslint-disable react-native/no-inline-styles */
+import 'expo-dev-client';
+import * as React from 'react';
+import { Button, ScrollView, Text } from 'react-native';
+import { DataTable } from 'react-native-paper';
+import dayjs from 'dayjs';
+import Healthkit, { HKCategoryTypeIdentifier, HKCharacteristicTypeIdentifier, HKCorrelationTypeIdentifier, HKInsulinDeliveryReason, HKQuantityTypeIdentifier, HKStatisticsOptions, HKUnit, HKWeatherCondition, HKWorkoutActivityType, } from '../src/index'; // this way we can work with the working copy - but keep in mind native changes requires a new build 🚀
+const DisplayWorkout = ({ workout }) => {
+    return (React.createElement(DataTable.Row, null,
+        React.createElement(DataTable.Cell, null, HKWorkoutActivityType[workout.workoutActivityType]),
+        React.createElement(DataTable.Cell, { style: { paddingRight: 10 }, numeric: true }, workout ? workout.duration.toFixed(0) + 's' : '-'),
+        React.createElement(DataTable.Cell, null, workout
+            ? workout.totalDistance?.quantity.toFixed(1) +
+                ' ' +
+                workout.totalDistance?.unit
+            : '-'),
+        React.createElement(DataTable.Cell, null, workout
+            ? workout.totalEnergyBurned?.quantity.toFixed(1) +
+                ' ' +
+                workout.totalEnergyBurned?.unit
+            : '-')));
+};
+const DisplayQuantitySample = ({ title, sample }) => {
+    return (React.createElement(DataTable.Row, null,
+        React.createElement(DataTable.Cell, null, title),
+        React.createElement(DataTable.Cell, { style: { paddingRight: 10 }, numeric: true }, sample ? sample.quantity.toFixed(1) : '-'),
+        React.createElement(DataTable.Cell, null, sample ? sample.unit : '-'),
+        React.createElement(DataTable.Cell, null, sample ? sample.startDate.toLocaleTimeString() : '-')));
+};
+const DisplayCategorySample = ({ title, sample }) => {
+    return (React.createElement(DataTable.Row, null,
+        React.createElement(DataTable.Cell, null, title),
+        React.createElement(DataTable.Cell, { style: { paddingRight: 10 }, numeric: true }, sample ? sample.value : '-'),
+        React.createElement(DataTable.Cell, null, sample ? sample.startDate.toLocaleTimeString() : '-'),
+        React.createElement(DataTable.Cell, null, sample ? sample.endDate.toLocaleTimeString() : '-')));
+};
+const DisplayStat = ({ title, sample }) => {
+    return (React.createElement(DataTable.Row, null,
+        React.createElement(DataTable.Cell, null, title),
+        React.createElement(DataTable.Cell, { style: { paddingRight: 10 }, numeric: true }, sample ? sample.quantity.toFixed(1) : '-'),
+        React.createElement(DataTable.Cell, null, sample ? sample.unit : '-'),
+        React.createElement(DataTable.Cell, null, "N/A")));
+};
+function DataView() {
+    const [dateOfBirth, setDateOfBirth] = React.useState(null);
+    const [bloodGlucoseSamples, setBloodGlucoseSamples] = React.useState(null);
+    const bodyFat = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.bodyFatPercentage);
+    const bloodGlucose = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.bloodGlucose);
+    const bodyWeight = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.bodyMass);
+    const heartRate = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.heartRate);
+    const lastWorkout = Healthkit.useMostRecentWorkout();
+    const lastMindfulSession = Healthkit.useMostRecentCategorySample(HKCategoryTypeIdentifier.mindfulSession);
+    const walkingSpeed = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.walkingSpeed);
+    const sixMinWalk = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.sixMinuteWalkTestDistance);
+    const walkingStepLength = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.walkingStepLength);
+    const walkingAsymmetryPercentage = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.walkingAsymmetryPercentage);
+    const walkingDoubleSupportPercentage = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.walkingDoubleSupportPercentage);
+    const stairAscentSpeed = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.stairAscentSpeed);
+    const stairDescentSpeed = Healthkit.useMostRecentQuantitySample(HKQuantityTypeIdentifier.stairDescentSpeed);
+    const [queryStatisticsResponse, setQueryStatisticsResponse] = React.useState(null);
+    const writeSampleToHealthkit = () => {
+        Healthkit.saveQuantitySample(HKQuantityTypeIdentifier.insulinDelivery, HKUnit.InternationalUnit, 4.2, {
+            metadata: {
+                HKInsulinDeliveryReason: HKInsulinDeliveryReason.basal,
+            },
+        });
+        Healthkit.saveCorrelationSample(HKCorrelationTypeIdentifier.food, [
+            {
+                quantityType: HKQuantityTypeIdentifier.dietaryCaffeine,
+                unit: HKUnit.Grams,
+                quantity: 1,
+                metadata: {},
+            },
+            {
+                quantityType: HKQuantityTypeIdentifier.dietaryEnergyConsumed,
+                unit: HKUnit.Kilocalories,
+                quantity: 1,
+                metadata: {},
+            },
+        ]);
+        Healthkit.saveWorkoutSample(HKWorkoutActivityType.archery, [
+            {
+                quantityType: HKQuantityTypeIdentifier.activeEnergyBurned,
+                unit: HKUnit.Kilocalories,
+                quantity: 63,
+                metadata: {},
+            },
+            {
+                quantityType: HKQuantityTypeIdentifier.appleExerciseTime,
+                unit: HKUnit.Minutes,
+                quantity: 11,
+                metadata: {},
+            },
+        ], new Date(), {
+            metadata: {
+                HKWeatherCondition: HKWeatherCondition.hurricane,
+            },
+        });
+        Healthkit.getDateOfBirth().then(setDateOfBirth);
+        Healthkit.queryStatisticsForQuantity(HKQuantityTypeIdentifier.heartRate, [
+            HKStatisticsOptions.discreteAverage,
+            HKStatisticsOptions.discreteMax,
+            HKStatisticsOptions.discreteMin,
+        ], dayjs().startOf('day').toDate()).then(setQueryStatisticsResponse);
+        Healthkit.queryQuantitySamples(HKQuantityTypeIdentifier.bloodGlucose, {
+            ascending: true,
+            from: dayjs().startOf('day').toDate(),
+            to: new Date(),
+        }).then(setBloodGlucoseSamples);
+    };
+    console.log(walkingDoubleSupportPercentage);
+    return (React.createElement(ScrollView, { style: { flex: 1, paddingTop: 40 } },
+        React.createElement(Button, { title: "Write Sample to HealthKit", onPress: () => writeSampleToHealthkit() }),
+        React.createElement(Text, null,
+            "Date of birth: ",
+            dateOfBirth?.toLocaleDateString()),
+        React.createElement(DataTable, null,
+            React.createElement(DataTable.Header, null,
+                React.createElement(DataTable.Title, null, "Metric"),
+                React.createElement(DataTable.Title, { style: { paddingRight: 10 }, numeric: true }, "Value"),
+                React.createElement(DataTable.Title, null, "Unit"),
+                React.createElement(DataTable.Title, null, "Time")),
+            React.createElement(DisplayQuantitySample, { sample: bodyFat, title: "Body fat" }),
+            React.createElement(DisplayQuantitySample, { sample: bodyWeight, title: "Weight" }),
+            React.createElement(DisplayQuantitySample, { sample: heartRate, title: "Heart rate" }),
+            React.createElement(DisplayQuantitySample, { sample: bloodGlucose, title: "Glucose" }),
+            React.createElement(DisplayStat, { sample: queryStatisticsResponse?.averageQuantity, title: "Avg. HR" }),
+            React.createElement(DisplayStat, { sample: queryStatisticsResponse?.maximumQuantity, title: "High HR" }),
+            React.createElement(DisplayStat, { sample: queryStatisticsResponse?.minimumQuantity, title: "Low HR" }),
+            React.createElement(DisplayCategorySample, { sample: lastMindfulSession, title: "Mindful" }),
+            React.createElement(DataTable.Header, null,
+                React.createElement(DataTable.Title, null, "Workout"),
+                React.createElement(DataTable.Title, { style: { paddingRight: 10 }, numeric: true }, "Duration"),
+                React.createElement(DataTable.Title, null, "Distance"),
+                React.createElement(DataTable.Title, null, "Energy")),
+            lastWorkout ? React.createElement(DisplayWorkout, { workout: lastWorkout }) : null,
+            React.createElement(DataTable.Header, null,
+                React.createElement(DataTable.Title, null, "Blood Glucose"),
+                React.createElement(DataTable.Title, { style: { paddingRight: 10 }, numeric: true }, "Value"),
+                React.createElement(DataTable.Title, null, "Units"),
+                React.createElement(DataTable.Title, null, "Time")),
+            bloodGlucoseSamples
+                ? bloodGlucoseSamples.map((sample) => (React.createElement(DisplayQuantitySample, { sample: sample, title: "Glucose" })))
+                : null,
+            React.createElement(DataTable.Header, null,
+                React.createElement(DataTable.Title, null, "Mobility"),
+                React.createElement(DataTable.Title, { style: { paddingRight: 10 }, numeric: true }, "Value"),
+                React.createElement(DataTable.Title, null, "Units"),
+                React.createElement(DataTable.Title, null, "Time")),
+            React.createElement(DisplayQuantitySample, { sample: walkingSpeed, title: "Walking speed" }),
+            React.createElement(DisplayQuantitySample, { sample: sixMinWalk, title: "Six-minute walk test" }),
+            React.createElement(DisplayQuantitySample, { sample: walkingStepLength, title: "Walking Step Length" }),
+            React.createElement(DisplayQuantitySample, { sample: walkingAsymmetryPercentage, title: "Walking Asymmetry" }),
+            React.createElement(DisplayQuantitySample, { sample: walkingDoubleSupportPercentage, title: "Walking Double Support" }),
+            React.createElement(DisplayQuantitySample, { sample: stairAscentSpeed, title: "Stair Ascent" }),
+            React.createElement(DisplayQuantitySample, { sample: stairDescentSpeed, title: "Stair Descent" }))));
+}
+const App = () => {
+    const [hasPermissions, setHasPermissions] = React.useState(false);
+    React.useEffect(() => {
+        Healthkit.requestAuthorization([
+            HKCharacteristicTypeIdentifier.biologicalSex,
+            HKCharacteristicTypeIdentifier.bloodType,
+            HKCharacteristicTypeIdentifier.dateOfBirth,
+            HKCharacteristicTypeIdentifier.fitzpatrickSkinType,
+            HKQuantityTypeIdentifier.waistCircumference,
+            HKQuantityTypeIdentifier.bodyMassIndex,
+            HKQuantityTypeIdentifier.bodyMass,
+            HKQuantityTypeIdentifier.heartRate,
+            HKQuantityTypeIdentifier.bloodGlucose,
+            HKQuantityTypeIdentifier.insulinDelivery,
+            HKQuantityTypeIdentifier.activeEnergyBurned,
+            HKCategoryTypeIdentifier.mindfulSession,
+            HKQuantityTypeIdentifier.dietaryCaffeine,
+            HKQuantityTypeIdentifier.dietaryEnergyConsumed,
+            HKQuantityTypeIdentifier.walkingSpeed,
+            HKQuantityTypeIdentifier.walkingAsymmetryPercentage,
+            HKQuantityTypeIdentifier.walkingDoubleSupportPercentage,
+            HKQuantityTypeIdentifier.stairAscentSpeed,
+            HKQuantityTypeIdentifier.stairDescentSpeed,
+            HKQuantityTypeIdentifier.walkingStepLength,
+            'HKWorkoutTypeIdentifier',
+        ], [
+            HKQuantityTypeIdentifier.waistCircumference,
+            HKQuantityTypeIdentifier.activeEnergyBurned,
+            HKQuantityTypeIdentifier.bloodGlucose,
+            HKQuantityTypeIdentifier.insulinDelivery,
+            HKQuantityTypeIdentifier.bodyFatPercentage,
+            HKCategoryTypeIdentifier.mindfulSession,
+            HKQuantityTypeIdentifier.dietaryCaffeine,
+            HKQuantityTypeIdentifier.dietaryEnergyConsumed,
+            'HKWorkoutTypeIdentifier',
+        ]).then(setHasPermissions);
+    }, []);
+    return hasPermissions ? (React.createElement(DataView, null)) : (React.createElement(Text, { style: { paddingTop: 40, textAlign: 'center' } }, "Waiting for user to authorize.."));
+};
+export default App;

package/lib/index.ios.js

@@ -0,0 +1,310 @@
+import { useState, useEffect, useCallback } from 'react';
+import Native, { EventEmitter, HKQuantityTypeIdentifier, HKUnit, } from './native-types';
+const getPreferredUnit = async (type) => {
+    const [unit] = await getPreferredUnits([type]);
+    return unit;
+};
+const ensureUnit = async (type, providedUnit) => {
+    if (providedUnit) {
+        return providedUnit;
+    }
+    const unit = await Native.getPreferredUnits([type]);
+    return unit[type];
+};
+function deserializeSample(sample) {
+    return {
+        ...sample,
+        startDate: new Date(sample.startDate),
+        endDate: new Date(sample.endDate),
+    };
+}
+function deserializeWorkout(sample) {
+    return {
+        ...sample,
+        startDate: new Date(sample.startDate),
+        endDate: new Date(sample.endDate),
+    };
+}
+const deserializCategorySample = (sample) => {
+    return {
+        ...sample,
+        startDate: new Date(sample.startDate),
+        endDate: new Date(sample.endDate),
+    };
+};
+const serializeDate = (date) => {
+    return date ? date.toISOString() : new Date(0).toISOString();
+};
+const prepareOptions = (options) => {
+    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 = async (identifier, options) => {
+    const unit = await ensureUnit(identifier, options.unit);
+    const opts = prepareOptions(options);
+    const quantitySamples = await Native.queryQuantitySamples(identifier, unit, opts.from, opts.to, opts.limit, opts.ascending);
+    return quantitySamples.map(deserializeSample);
+};
+const subscribeToChanges = async (identifier, callback) => {
+    const subscription = EventEmitter.addListener('onChange', ({ typeIdentifier }) => {
+        if (typeIdentifier === identifier) {
+            callback();
+        }
+    });
+    const queryId = await Native.subscribeToObserverQuery(identifier).catch((error) => {
+        subscription.remove();
+        return Promise.reject(error);
+    });
+    return () => {
+        subscription.remove();
+        return Native.unsubscribeQuery(queryId);
+    };
+};
+const getMostRecentQuantitySample = async (identifier, unit) => {
+    const samples = await queryQuantitySamples(identifier, {
+        limit: 1,
+        unit: unit,
+    });
+    return samples[0];
+};
+function useMostRecentWorkout(options) {
+    const [workout, setWorkout] = useState(null);
+    useEffect(() => {
+        let cancelSubscription;
+        const init = async () => {
+            const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(options);
+            cancelSubscription = await subscribeToChanges('HKWorkoutTypeIdentifier', () => {
+                getMostRecentWorkout({ energyUnit, distanceUnit }).then(setWorkout);
+            });
+        };
+        init();
+        return () => {
+            cancelSubscription && cancelSubscription();
+        };
+    }, [options]);
+    return workout;
+}
+const getMostRecentCategorySample = async (identifier) => {
+    const samples = await queryCategorySamples(identifier, {
+        limit: 1,
+        ascending: false,
+    });
+    return samples[0];
+};
+function useMostRecentCategorySample(identifier) {
+    const [category, setCategory] = useState(null);
+    const updater = useCallback(() => {
+        getMostRecentCategorySample(identifier).then(setCategory);
+    }, [identifier]);
+    useSubscribeToChanges(identifier, updater);
+    return category;
+}
+function useSubscribeToChanges(identifier, onChange) {
+    useEffect(() => {
+        let cancelSubscription;
+        const init = async () => {
+            cancelSubscription = await subscribeToChanges(identifier, onChange);
+        };
+        init();
+        return () => {
+            cancelSubscription && cancelSubscription();
+        };
+    }, [identifier, onChange]);
+}
+function useMostRecentQuantitySample(identifier, unit) {
+    const [lastSample, setLastSample] = useState(null);
+    useEffect(() => {
+        let cancelSubscription;
+        const init = async () => {
+            const actualUnit = await ensureUnit(identifier, unit);
+            cancelSubscription = await subscribeToChanges(identifier, () => {
+                getMostRecentQuantitySample(identifier, actualUnit).then((value) => {
+                    setLastSample(value);
+                });
+            });
+        };
+        init();
+        return () => {
+            cancelSubscription && cancelSubscription();
+        };
+    }, [identifier, unit]);
+    return lastSample;
+}
+const saveQuantitySample = (identifier, unit, value, options) => {
+    const start = options?.start || options?.end || new Date();
+    const end = options?.end || options?.start || new Date();
+    const metadata = options?.metadata || {};
+    return Native.saveQuantitySample(identifier, unit, value, start.toISOString(), end.toISOString(), metadata);
+};
+const queryStatisticsForQuantity = async (identifier, options, from, to, 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 response = {
+        ...rawResponse,
+        ...(mostRecentQuantityDateInterval
+            ? {
+                mostRecentQuantityDateInterval: {
+                    from: new Date(mostRecentQuantityDateInterval.from),
+                    to: new Date(mostRecentQuantityDateInterval.to),
+                },
+            }
+            : {}),
+    };
+    return response;
+};
+const requestAuthorization = (read, write = []) => {
+    const readPermissions = read.reduce((obj, cur) => {
+        return { ...obj, [cur]: true };
+    }, {});
+    const writePermissions = write.reduce((obj, cur) => {
+        return { ...obj, [cur]: true };
+    }, {});
+    return Native.requestAuthorization(writePermissions, readPermissions);
+};
+const getDateOfBirth = async () => {
+    const dateOfBirth = await Native.getDateOfBirth();
+    return new Date(dateOfBirth);
+};
+const getRequestStatusForAuthorization = (read, write = []) => {
+    const readPermissions = read.reduce((obj, cur) => {
+        return { ...obj, [cur]: true };
+    }, {});
+    const writePermissions = write.reduce((obj, cur) => {
+        return { ...obj, [cur]: true };
+    }, {});
+    return Native.getRequestStatusForAuthorization(writePermissions, readPermissions);
+};
+const queryCategorySamples = async (identifier, options) => {
+    const opts = prepareOptions(options);
+    const results = await Native.queryCategorySamples(identifier, opts.from, opts.to, opts.limit, opts.ascending);
+    return results.map(deserializCategorySample);
+};
+async function getPreferredUnitsTyped(options) {
+    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];
+        }
+        if (!distanceUnit) {
+            distanceUnit = units[HKQuantityTypeIdentifier.activeEnergyBurned];
+        }
+    }
+    if (!energyUnit) {
+        energyUnit = HKUnit.Kilocalories;
+    }
+    if (!distanceUnit) {
+        distanceUnit = HKUnit.Meters;
+    }
+    return { energyUnit, distanceUnit };
+}
+const queryWorkouts = async (options) => {
+    const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(options);
+    const opts = prepareOptions(options);
+    const workouts = await Native.queryWorkoutSamples(energyUnit, distanceUnit, opts.from, opts.to, opts.limit, opts.ascending);
+    return workouts.map(deserializeWorkout);
+};
+const getMostRecentWorkout = async (options) => {
+    const workouts = await queryWorkouts({
+        limit: 1,
+        ascending: false,
+        energyUnit: options?.energyUnit,
+        distanceUnit: options?.distanceUnit,
+    });
+    return workouts[0];
+};
+function saveCategorySample(identifier, value, options) {
+    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 || {});
+}
+const getPreferredUnits = async (identifiers) => {
+    const units = await Native.getPreferredUnits(identifiers);
+    return identifiers.map((i) => units[i]);
+};
+const buildUnitWithPrefix = (prefix, unit) => {
+    return `${prefix}${unit}`;
+};
+function deserializeCorrelation(s) {
+    return {
+        ...s,
+        objects: s.objects.map((o) => {
+            // @ts-ignore
+            if (o.quantity !== undefined) {
+                return deserializeSample(o);
+            }
+            return deserializCategorySample(o);
+        }),
+        endDate: new Date(s.endDate),
+        startDate: new Date(s.startDate),
+    };
+}
+function ensureMetadata(metadata) {
+    return metadata || {};
+}
+const queryCorrelationSamples = async (typeIdentifier, options) => {
+    const opts = prepareOptions(options);
+    const correlations = await Native.queryCorrelationSamples(typeIdentifier, opts.from, opts.to);
+    return correlations.map(deserializeCorrelation);
+};
+const saveCorrelationSample = async (typeIdentifier, samples, options) => {
+    const start = (options?.start || new Date()).toISOString();
+    const end = (options?.end || new Date()).toISOString();
+    return Native.saveCorrelationSample(typeIdentifier, samples, start, end, ensureMetadata(options?.metadata));
+};
+const saveWorkoutSample = (typeIdentifier, quantities, _start, options) => {
+    const start = _start.toISOString();
+    const end = (options?.end || new Date()).toISOString();
+    return Native.saveWorkoutSample(typeIdentifier, quantities, start, end, ensureMetadata(options?.metadata));
+};
+const Healthkit = {
+    authorizationStatusFor: Native.authorizationStatusFor,
+    isHealthDataAvailable: Native.isHealthDataAvailable,
+    buildUnitWithPrefix,
+    disableAllBackgroundDelivery: Native.disableAllBackgroundDelivery,
+    disableBackgroundDelivery: Native.disableBackgroundDelivery,
+    enableBackgroundDelivery: Native.enableBackgroundDelivery,
+    // simple convenience getters
+    getBiologicalSex: Native.getBiologicalSex,
+    getFitzpatrickSkinType: Native.getFitzpatrickSkinType,
+    getWheelchairUse: Native.getWheelchairUse,
+    getBloodType: Native.getBloodType,
+    getDateOfBirth,
+    getMostRecentQuantitySample,
+    getMostRecentCategorySample,
+    getMostRecentWorkout,
+    getPreferredUnit,
+    getPreferredUnits,
+    getRequestStatusForAuthorization,
+    // query methods
+    queryCategorySamples,
+    queryCorrelationSamples,
+    queryQuantitySamples,
+    queryStatisticsForQuantity,
+    queryWorkouts,
+    requestAuthorization,
+    // save methods
+    saveCategorySample,
+    saveCorrelationSample,
+    saveQuantitySample,
+    saveWorkoutSample,
+    // subscriptions
+    subscribeToChanges,
+    // hooks
+    useMostRecentCategorySample,
+    useMostRecentQuantitySample,
+    useMostRecentWorkout,
+    useSubscribeToChanges,
+};
+export * from './types';
+export * from './native-types';
+export default Healthkit;

package/lib/index.js

@@ -0,0 +1,44 @@
+import { Platform } from 'react-native';
+const notAvailableError = 'Platform "' +
+    Platform.OS +
+    '" not supported, use isHealthDataAvailable to check for availability before using it';
+const UnavailableFn = () => {
+    throw new Error(notAvailableError);
+};
+const Healthkit = {
+    authorizationStatusFor: UnavailableFn,
+    buildUnitWithPrefix: UnavailableFn,
+    disableAllBackgroundDelivery: UnavailableFn,
+    disableBackgroundDelivery: UnavailableFn,
+    enableBackgroundDelivery: UnavailableFn,
+    getBiologicalSex: UnavailableFn,
+    getBloodType: UnavailableFn,
+    getDateOfBirth: UnavailableFn,
+    getFitzpatrickSkinType: UnavailableFn,
+    getMostRecentCategorySample: UnavailableFn,
+    getMostRecentQuantitySample: UnavailableFn,
+    getMostRecentWorkout: UnavailableFn,
+    getPreferredUnit: UnavailableFn,
+    getPreferredUnits: UnavailableFn,
+    getRequestStatusForAuthorization: UnavailableFn,
+    getWheelchairUse: UnavailableFn,
+    isHealthDataAvailable: () => Promise.resolve(false),
+    queryCategorySamples: UnavailableFn,
+    queryCorrelationSamples: UnavailableFn,
+    queryQuantitySamples: UnavailableFn,
+    queryStatisticsForQuantity: UnavailableFn,
+    queryWorkouts: UnavailableFn,
+    requestAuthorization: UnavailableFn,
+    saveCategorySample: UnavailableFn,
+    saveCorrelationSample: UnavailableFn,
+    saveQuantitySample: UnavailableFn,
+    saveWorkoutSample: UnavailableFn,
+    subscribeToChanges: UnavailableFn,
+    useMostRecentCategorySample: UnavailableFn,
+    useMostRecentQuantitySample: UnavailableFn,
+    useMostRecentWorkout: UnavailableFn,
+    useSubscribeToChanges: UnavailableFn,
+};
+export * from './types';
+export * from './native-types';
+export default Healthkit;

package/lib/module/index.ios.js

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import Native, { EventEmitter, HKQuantityTypeIdentifier, HKUnit } from './native-types';
 
 const getPreferredUnit = async type => {
@@ -63,7 +63,7 @@ const queryQuantitySamples = async (identifier, options) => {
 };
 
 const subscribeToChanges = async (identifier, callback) => {
-  const subscription = EventEmitter.addListener('onChange', (_ref) => {
+  const subscription = EventEmitter.addListener('onChange', _ref => {
     let {
       typeIdentifier
     } = _ref;
@@ -116,7 +116,7 @@ function useMostRecentWorkout(options) {
   return workout;
 }
 
-const getMostRecentCategorySample = async (identifier) => {
+const getMostRecentCategorySample = async identifier => {
   const samples = await queryCategorySamples(identifier, {
     limit: 1,
     ascending: false
@@ -340,6 +340,10 @@ const saveWorkoutSample = (typeIdentifier, quantities, _start, options) => {
   return Native.saveWorkoutSample(typeIdentifier, quantities, start, end, ensureMetadata(options === null || options === void 0 ? void 0 : options.metadata));
 };
 
+const getWorkoutRoutes = workoutUUID => {
+  return Native.getWorkoutRoutes(workoutUUID);
+};
+
 const Healthkit = {
   authorizationStatusFor: Native.authorizationStatusFor,
   isHealthDataAvailable: Native.isHealthDataAvailable,
@@ -359,6 +363,7 @@ const Healthkit = {
   getPreferredUnit,
   getPreferredUnits,
   getRequestStatusForAuthorization,
+  getWorkoutRoutes,
   // query methods
   queryCategorySamples,
   queryCorrelationSamples,
@@ -379,7 +384,7 @@ const Healthkit = {
   useMostRecentWorkout,
   useSubscribeToChanges
 };
-export * from './types';
 export * from './native-types';
+export * from './types';
 export default Healthkit;
 //# sourceMappingURL=index.ios.js.map