@kingstinct/react-native-healthkit 9.0.0 → 9.0.2

package/lib/commonjs/utils/getMostRecentCategorySample.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMostRecentCategorySample = getMostRecentCategorySample;
+const modules_1 = require("../modules");
+async function getMostRecentCategorySample(identifier) {
+    const samples = await modules_1.CategoryTypes.queryCategorySamples(identifier, {
+        limit: 1,
+        ascending: false,
+    });
+    return samples[0];
+}
+exports.default = getMostRecentCategorySample;

package/lib/commonjs/utils/getMostRecentQuantitySample.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+async function getMostRecentQuantitySample(identifier, unit) {
+    const samples = await modules_1.QuantityTypes.queryQuantitySamples(identifier, {
+        limit: 1,
+        unit,
+    });
+    return samples[0];
+}
+exports.default = getMostRecentQuantitySample;

package/lib/commonjs/utils/getMostRecentWorkout.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+const getMostRecentWorkout = async (options) => {
+    const workouts = await modules_1.Workouts.queryWorkoutSamples({
+        limit: 1,
+        ascending: false,
+        energyUnit: options?.energyUnit,
+        distanceUnit: options?.distanceUnit,
+    });
+    return workouts[0];
+};
+exports.default = getMostRecentWorkout;

package/lib/commonjs/utils/getPreferredUnit.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+const getPreferredUnit = async (quantityType) => {
+    const units = await modules_1.Core.getPreferredUnits([quantityType]);
+    const unit = units[0]?.unit;
+    if (!unit) {
+        throw new Error(`No preferred unit found for quantity type: ${quantityType}`);
+    }
+    return unit;
+};
+exports.default = getPreferredUnit;

package/lib/commonjs/utils/getQuantitySampleById.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+async function getQuantitySampleById(identifier, uuid, unit) {
+    const samples = await modules_1.QuantityTypes.queryQuantitySamples(identifier, {
+        limit: 1,
+        unit,
+        filter: {
+            uuid: uuid,
+        },
+    });
+    return samples[0];
+}
+exports.default = getQuantitySampleById;

package/lib/commonjs/utils/getWorkoutById.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const modules_1 = require("../modules");
+const getWorkoutById = async (uuid, options) => {
+    const workouts = await modules_1.Workouts.queryWorkoutSamples({
+        limit: 1,
+        filter: {
+            uuid: uuid,
+        },
+        energyUnit: options?.energyUnit,
+        distanceUnit: options?.distanceUnit,
+    });
+    return workouts[0];
+};
+exports.default = getWorkoutById;

package/lib/commonjs/utils/subscribeToChanges.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToChanges = void 0;
+const modules_1 = require("../modules");
+const subscribeToChanges = (identifier, callback) => {
+    const queryId = modules_1.Core.subscribeToObserverQuery(identifier, callback);
+    return {
+        remove: () => modules_1.Core.unsubscribeQuery(queryId),
+    };
+};
+exports.subscribeToChanges = subscribeToChanges;

package/lib/module/hooks/useCategorySampleById.js

@@ -0,0 +1,30 @@
+import { useCallback, useState } from 'react';
+import getCategorySampleById from '../utils/getCategorySampleById';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent sample for the given category type.
+ */
+export function useCategorySampleById(identifier, uuid) {
+    const [sample, setSample] = useState();
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const updater = useCallback(async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const fetchedSample = await getCategorySampleById(identifier, uuid);
+            setSample(fetchedSample);
+        }
+        catch (err) {
+            setError(err instanceof Error
+                ? err
+                : new Error('Unknown error fetching category sample by ID'));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [identifier, uuid]);
+    useSubscribeToChanges(identifier, updater);
+    return { sample, isLoading, error };
+}
+export default useCategorySampleById;

package/lib/module/hooks/useHealthkitAuthorization.js

@@ -0,0 +1,30 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { Core } from '../modules';
+/**
+ * @description Hook to retrieve the current authorization status for the given types, and request authorization if needed.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614152-requestauthorization Apple Docs - requestAuthorization}
+ * @see {@link https://developer.apple.com/documentation/healthkit/authorizing_access_to_health_data Apple Docs - Authorizing access to health data}
+ */
+export const useHealthkitAuthorization = (read, write) => {
+    const [status, setStatus] = useState(null);
+    const readMemo = useRef(read);
+    const writeMemo = useRef(write);
+    useEffect(() => {
+        readMemo.current = read;
+        writeMemo.current = write;
+    }, [read, write]);
+    const refreshAuthStatus = useCallback(async () => {
+        const auth = await Core.getRequestStatusForAuthorization(writeMemo.current ?? [], readMemo.current);
+        setStatus(auth);
+        return auth;
+    }, []);
+    const request = useCallback(async () => {
+        await Core.requestAuthorization(writeMemo.current ?? [], readMemo.current);
+        return refreshAuthStatus();
+    }, [refreshAuthStatus]);
+    useEffect(() => {
+        void refreshAuthStatus();
+    }, [refreshAuthStatus]);
+    return [status, request];
+};
+export default useHealthkitAuthorization;

package/lib/module/hooks/useIsHealthDataAvailable.js

@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+import { Core } from '../modules';
+/**
+ * @description Now there is a Core.isHealthDataAvailable() that can be called synchronously. By default, HealthKit data is available on iOS and watchOS. HealthKit data is also available on iPadOS 17 or later. However, devices running in an enterprise environment may restrict access to HealthKit data.
+ * @see {@link https://developer.apple.com/documentation/healthkit/hkhealthstore/1614180-ishealthdataavailable Apple HealthKit isHealthDataAvailable}
+ * @returns {boolean | null} true if HealthKit is available; otherwise, false. null while initializing.
+ */
+export const useIsHealthDataAvailable = () => {
+    const [isAvailable, setIsAvailable] = useState(null);
+    useEffect(() => {
+        const init = async () => {
+            const res = await Core.isHealthDataAvailableAsync();
+            setIsAvailable(res);
+        };
+        void init();
+    }, []);
+    return isAvailable;
+};
+export default useIsHealthDataAvailable;

package/lib/module/hooks/useMostRecentCategorySample.js

@@ -0,0 +1,15 @@
+import { useCallback, useState } from 'react';
+import getMostRecentCategorySample from '../utils/getMostRecentCategorySample';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent sample for the given category type.
+ */
+export function useMostRecentCategorySample(identifier) {
+    const [category, setCategory] = useState();
+    const updater = useCallback(() => {
+        void getMostRecentCategorySample(identifier).then(setCategory);
+    }, [identifier]);
+    useSubscribeToChanges(identifier, updater);
+    return category;
+}
+export default useMostRecentCategorySample;

package/lib/module/hooks/useMostRecentQuantitySample.js

@@ -0,0 +1,16 @@
+import { useCallback, useState } from 'react';
+import getMostRecentQuantitySample from '../utils/getMostRecentQuantitySample';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent sample for the given quantity type.
+ */
+export function useMostRecentQuantitySample(identifier, unit) {
+    const [lastSample, setLastSample] = useState();
+    const fetchMostRecentSample = useCallback(async () => {
+        const value = await getMostRecentQuantitySample(identifier, unit);
+        setLastSample(value);
+    }, [identifier, unit]);
+    useSubscribeToChanges(identifier, fetchMostRecentSample);
+    return lastSample;
+}
+export default useMostRecentQuantitySample;

package/lib/module/hooks/useMostRecentWorkout.js

@@ -0,0 +1,25 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import getMostRecentWorkout from '../utils/getMostRecentWorkout';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent workout sample.
+ */
+export function useMostRecentWorkout(options) {
+    const [workout, setWorkout] = useState();
+    const optionsRef = useRef(options);
+    useEffect(() => {
+        optionsRef.current = options;
+    }, [options]);
+    const update = useCallback(async () => {
+        setWorkout(await getMostRecentWorkout({
+            energyUnit: optionsRef.current?.energyUnit,
+            distanceUnit: optionsRef.current?.distanceUnit,
+        }));
+    }, []);
+    useEffect(() => {
+        void update();
+    }, [update]);
+    useSubscribeToChanges('HKWorkoutTypeIdentifier', update);
+    return workout;
+}
+export default useMostRecentWorkout;

package/lib/module/hooks/useQuantitySampleById.js

@@ -0,0 +1,28 @@
+import { useCallback, useState } from 'react';
+import getQuantitySampleById from '../utils/getQuantitySampleById';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent sample for the given quantity type.
+ */
+export function useQuantitySampleById(identifier, uuid, options = {}) {
+    const [sample, setSample] = useState();
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchMostRecentSample = useCallback(async () => {
+        setIsLoading(true);
+        try {
+            const sample = await getQuantitySampleById(identifier, uuid, options?.unit);
+            setSample(sample);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [identifier, uuid, options.unit]);
+    useSubscribeToChanges(identifier, fetchMostRecentSample);
+    return { sample, isLoading, error };
+}
+export default useQuantitySampleById;

package/lib/module/hooks/useSources.js

@@ -0,0 +1,14 @@
+import { useCallback, useEffect, useState } from 'react';
+import { Core } from '../modules';
+export function useSources(identifier) {
+    const [result, setResult] = useState(null);
+    const update = useCallback(async () => {
+        const res = await Core.querySources(identifier);
+        setResult(res);
+    }, [identifier]);
+    useEffect(() => {
+        void update();
+    }, [update]);
+    return result;
+}
+export default useSources;

package/lib/module/hooks/useStatisticsForQuantity.js

@@ -0,0 +1,20 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import useSubscribeToChanges from './useSubscribeToChanges';
+import { QuantityTypes } from '../modules';
+export function useStatisticsForQuantity(identifier, options, from, to, unit) {
+    const [result, setResult] = useState(null);
+    const optionsRef = useRef(options);
+    useEffect(() => {
+        optionsRef.current = options;
+    }, [options]);
+    const update = useCallback(async () => {
+        const res = await QuantityTypes.queryStatisticsForQuantity(identifier, optionsRef.current, { filter: { startDate: from, endDate: to }, unit });
+        setResult(res);
+    }, [identifier, from, to, unit]);
+    useEffect(() => {
+        void update();
+    }, [update]);
+    useSubscribeToChanges(identifier, update);
+    return result;
+}
+export default useStatisticsForQuantity;

package/lib/module/hooks/useSubscribeToChanges.js

@@ -0,0 +1,17 @@
+import { useEffect, useRef } from 'react';
+import { subscribeToChanges } from '../utils/subscribeToChanges';
+export function useSubscribeToChanges(identifier, onChange) {
+    const onChangeRef = useRef(onChange);
+    useEffect(() => {
+        onChangeRef.current = onChange;
+    }, [onChange]);
+    useEffect(() => {
+        const subscription = subscribeToChanges(identifier, (args) => {
+            onChangeRef.current(args);
+        });
+        return () => {
+            subscription.remove();
+        };
+    }, [identifier]);
+}
+export default useSubscribeToChanges;

package/lib/module/hooks/useWorkoutById.js

@@ -0,0 +1,40 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import getWorkoutById from '../utils/getWorkoutById';
+import useSubscribeToChanges from './useSubscribeToChanges';
+/**
+ * @returns the most recent workout sample.
+ */
+export function useWorkoutById(uuid, options) {
+    const [workout, setWorkout] = useState();
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const optionsRef = useRef(options);
+    useEffect(() => {
+        optionsRef.current = options;
+    }, [options]);
+    const update = useCallback(async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const fetchedWorkout = await getWorkoutById(uuid, {
+                energyUnit: optionsRef.current?.energyUnit,
+                distanceUnit: optionsRef.current?.distanceUnit,
+            });
+            setWorkout(fetchedWorkout);
+        }
+        catch (err) {
+            setError(err instanceof Error
+                ? err
+                : new Error('Unknown error fetching workout by ID'));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [uuid]);
+    useEffect(() => {
+        void update();
+    }, [update]);
+    useSubscribeToChanges('HKWorkoutTypeIdentifier', update);
+    return { workout, isLoading, error };
+}
+export default useWorkoutById;

package/lib/module/index.ios.js

@@ -0,0 +1,126 @@
+import { Platform } from 'react-native';
+import useHealthkitAuthorization from './hooks/useHealthkitAuthorization';
+import { useIsHealthDataAvailable } from './hooks/useIsHealthDataAvailable';
+import useMostRecentCategorySample from './hooks/useMostRecentCategorySample';
+import useMostRecentQuantitySample from './hooks/useMostRecentQuantitySample';
+import useMostRecentWorkout from './hooks/useMostRecentWorkout';
+import useSources from './hooks/useSources';
+import useStatisticsForQuantity from './hooks/useStatisticsForQuantity';
+import useSubscribeToChanges from './hooks/useSubscribeToChanges';
+import { CategoryTypes, Characteristics, Core, CorrelationTypes, HeartbeatSeries, QuantityTypes, StateOfMind, Workouts, } from './modules';
+import getMostRecentCategorySample from './utils/getMostRecentCategorySample';
+import getMostRecentQuantitySample from './utils/getMostRecentQuantitySample';
+import getMostRecentWorkout from './utils/getMostRecentWorkout';
+import getPreferredUnit from './utils/getPreferredUnit';
+const currentMajorVersionIOS = Platform.OS === 'ios' ? Number.parseInt(Platform.Version, 10) : 0;
+export { getMostRecentCategorySample, getMostRecentQuantitySample, getMostRecentWorkout, getPreferredUnit, useMostRecentCategorySample, useMostRecentQuantitySample, useMostRecentWorkout, useSubscribeToChanges, useHealthkitAuthorization, useIsHealthDataAvailable, useSources, useStatisticsForQuantity, };
+// Named exports - all functions bound to their respective modules
+export const authorizationStatusFor = Core.authorizationStatusFor.bind(Core);
+export const disableAllBackgroundDelivery = Core.disableAllBackgroundDelivery.bind(Core);
+export const disableBackgroundDelivery = Core.disableBackgroundDelivery.bind(Core);
+export const enableBackgroundDelivery = Core.enableBackgroundDelivery.bind(Core);
+export const getBiologicalSex = Characteristics.getBiologicalSex.bind(Characteristics);
+export const getBloodType = Characteristics.getBloodType.bind(Characteristics);
+export const getDateOfBirth = Characteristics.getDateOfBirth.bind(Characteristics);
+export const getFitzpatrickSkinType = Characteristics.getFitzpatrickSkinType.bind(Characteristics);
+export const getPreferredUnits = Core.getPreferredUnits.bind(Core);
+export const getRequestStatusForAuthorization = Core.getRequestStatusForAuthorization.bind(Core);
+export const getWheelchairUse = Characteristics.getWheelchairUse.bind(Characteristics);
+export const isHealthDataAvailable = Core.isHealthDataAvailable.bind(Core);
+export const isHealthDataAvailableAsync = Core.isHealthDataAvailableAsync.bind(Core);
+export const queryCategorySamples = CategoryTypes.queryCategorySamples.bind(CategoryTypes);
+export const queryCategorySamplesWithAnchor = CategoryTypes.queryCategorySamplesWithAnchor.bind(CategoryTypes);
+export const queryCorrelationSamples = CorrelationTypes.queryCorrelationSamples.bind(CorrelationTypes);
+export const queryHeartbeatSeriesSamples = HeartbeatSeries.queryHeartbeatSeriesSamples.bind(HeartbeatSeries);
+export const queryHeartbeatSeriesSamplesWithAnchor = HeartbeatSeries.queryHeartbeatSeriesSamplesWithAnchor.bind(HeartbeatSeries);
+export const queryQuantitySamples = QuantityTypes.queryQuantitySamples.bind(QuantityTypes);
+export const queryQuantitySamplesWithAnchor = QuantityTypes.queryQuantitySamplesWithAnchor.bind(QuantityTypes);
+export const queryStatisticsForQuantity = QuantityTypes.queryStatisticsForQuantity.bind(QuantityTypes);
+export const queryStatisticsCollectionForQuantity = QuantityTypes.queryStatisticsCollectionForQuantity.bind(QuantityTypes);
+export const queryWorkoutSamples = Workouts.queryWorkoutSamples.bind(Workouts);
+export const queryWorkoutSamplesWithAnchor = Workouts.queryWorkoutSamplesWithAnchor.bind(Workouts);
+export const querySources = Core.querySources.bind(Core);
+export const requestAuthorization = Core.requestAuthorization.bind(Core);
+export const deleteObjects = Core.deleteObjects.bind(Core);
+export const saveCategorySample = CategoryTypes.saveCategorySample.bind(CategoryTypes);
+export const saveCorrelationSample = CorrelationTypes.saveCorrelationSample.bind(CorrelationTypes);
+export const saveQuantitySample = QuantityTypes.saveQuantitySample.bind(QuantityTypes);
+export const saveWorkoutSample = Workouts.saveWorkoutSample.bind(Workouts);
+export const subscribeToChanges = Core.subscribeToObserverQuery.bind(Core);
+export const startWatchApp = Workouts.startWatchAppWithWorkoutConfiguration.bind(Workouts);
+export const isProtectedDataAvailable = Core.isProtectedDataAvailable.bind(Core);
+export const queryStateOfMindSamples = StateOfMind.queryStateOfMindSamples.bind(StateOfMind);
+export const saveStateOfMindSample = StateOfMind.saveStateOfMindSample.bind(StateOfMind);
+export const isQuantityCompatibleWithUnit = QuantityTypes.isQuantityCompatibleWithUnit.bind(QuantityTypes);
+export const unsubscribeQueries = Core.unsubscribeQueries.bind(Core);
+export const isObjectTypeAvailable = Core.isObjectTypeAvailable.bind(Core);
+export const isObjectTypeAvailableAsync = Core.isObjectTypeAvailableAsync.bind(Core);
+export const areObjectTypesAvailable = Core.areObjectTypesAvailable.bind(Core);
+export const areObjectTypesAvailableAsync = Core.areObjectTypesAvailableAsync.bind(Core);
+export const getBiologicalSexAsync = Characteristics.getBiologicalSexAsync.bind(Characteristics);
+export const getBloodTypeAsync = Characteristics.getBloodTypeAsync.bind(Characteristics);
+export const getDateOfBirthAsync = Characteristics.getDateOfBirthAsync.bind(Characteristics);
+export const getFitzpatrickSkinTypeAsync = Characteristics.getFitzpatrickSkinTypeAsync.bind(Characteristics);
+export const getWheelchairUseAsync = Characteristics.getWheelchairUseAsync.bind(Characteristics);
+export default {
+    authorizationStatusFor,
+    isObjectTypeAvailable,
+    isObjectTypeAvailableAsync,
+    areObjectTypesAvailable,
+    areObjectTypesAvailableAsync,
+    isQuantityCompatibleWithUnit,
+    disableAllBackgroundDelivery,
+    disableBackgroundDelivery,
+    enableBackgroundDelivery,
+    getBiologicalSex,
+    getBloodType,
+    getDateOfBirth,
+    getFitzpatrickSkinType,
+    getBiologicalSexAsync,
+    getBloodTypeAsync,
+    getDateOfBirthAsync,
+    getFitzpatrickSkinTypeAsync,
+    getWheelchairUseAsync,
+    getMostRecentCategorySample,
+    getMostRecentQuantitySample,
+    getMostRecentWorkout,
+    getPreferredUnits,
+    getPreferredUnit,
+    getRequestStatusForAuthorization,
+    getWheelchairUse,
+    isHealthDataAvailable,
+    isHealthDataAvailableAsync,
+    queryCategorySamples,
+    queryCategorySamplesWithAnchor,
+    queryCorrelationSamples,
+    queryHeartbeatSeriesSamples,
+    queryHeartbeatSeriesSamplesWithAnchor,
+    queryQuantitySamples,
+    queryQuantitySamplesWithAnchor,
+    queryStatisticsForQuantity,
+    queryStatisticsCollectionForQuantity,
+    queryWorkoutSamples,
+    queryWorkoutSamplesWithAnchor,
+    querySources,
+    requestAuthorization,
+    deleteObjects,
+    saveCategorySample,
+    saveCorrelationSample,
+    saveQuantitySample,
+    saveWorkoutSample,
+    subscribeToChanges,
+    unsubscribeQueries,
+    startWatchApp,
+    isProtectedDataAvailable,
+    queryStateOfMindSamples,
+    saveStateOfMindSample,
+    // hooks
+    useMostRecentCategorySample,
+    useMostRecentQuantitySample,
+    useMostRecentWorkout,
+    useSubscribeToChanges,
+    useHealthkitAuthorization,
+    useIsHealthDataAvailable,
+    useSources,
+    useStatisticsForQuantity,
+};