@kingstinct/react-native-healthkit 5.1.2 → 5.2.1

package/src/test-utils.ts

@@ -0,0 +1,10 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { act } from '@testing-library/react-native'
+
+const waitForNextUpdate = async () => {
+  await act(async () => {
+    await new Promise((resolve) => { setTimeout(resolve, 0) })
+  })
+}
+
+export default waitForNextUpdate

package/src/utils/getPreferredUnit.ts

@@ -4,11 +4,11 @@ import type { HKQuantityTypeIdentifier, HKUnit } from '../native-types'
 
 export type GetPreferredUnitFn = (
   identifier: HKQuantityTypeIdentifier
-) => Promise<HKUnit>;
+) => Promise<HKUnit | undefined>;
 
 const getPreferredUnit: GetPreferredUnitFn = async (type) => {
   const [unit] = await getPreferredUnits([type])
-  return unit!
+  return unit
 }
 
 export default getPreferredUnit

package/src/utils/subscribeToChanges.ts

@@ -1,5 +1,4 @@
-import { EventEmitter } from '..'
-import Native from '../native-types'
+import Native, { EventEmitter } from '../native-types'
 
 import type { HKSampleTypeIdentifier } from '..'
 

package/lib/example/App.js

@@ -1,197 +0,0 @@
-/* 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

@@ -1,310 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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;