react-native-healthkit-bridge/lib/hooks/useHealthKit.js

A comprehensive React Native bridge for Apple HealthKit with TypeScript support, advanced authorization, and flexible data queries

import { useCallback, useEffect, useState } from 'react';
import { HealthKitBridge } from '../core/HealthKitBridge';
// Singleton instance of HealthKitBridge with proper cleanup
let healthKitInstance = null;
function getHealthKitBridge() {
    if (!healthKitInstance) {
        healthKitInstance = new HealthKitBridge();
    }
    return healthKitInstance;
}
// Cleanup function for testing and memory management
export function cleanupHealthKitBridge() {
    healthKitInstance = null;
}
// Generic hook for quantitative data
export function useHealthKitQuantity(identifier, unit) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    const fetch = useCallback(async () => {
        setLoading(true);
        setError(null);
        try {
            const result = await getHealthKitBridge().getQuantitySamples(identifier, unit);
            // Convert to HealthKitQuantity format
            const formattedData = result.map((sample, index) => ({
                value: sample.value,
                unit,
                startDate: Date.now() / 1000 - (index * 86400),
                endDate: Date.now() / 1000 - (index * 86400) + 86400
            }));
            setData(formattedData);
        }
        catch (e) {
            setError((e === null || e === void 0 ? void 0 : e.message) || 'Error fetching data');
        }
        finally {
            setLoading(false);
        }
    }, [identifier, unit]);
    useEffect(() => {
        fetch();
    }, [fetch]);
    return { data, loading, error, refetch: fetch };
}
// Generic hook for categorical data
export function useHealthKitCategory(identifier) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    const fetch = useCallback(async () => {
        setLoading(true);
        setError(null);
        try {
            const result = await getHealthKitBridge().getCategorySamples(identifier);
            setData(result);
        }
        catch (e) {
            setError((e === null || e === void 0 ? void 0 : e.message) || 'Error fetching data');
        }
        finally {
            setLoading(false);
        }
    }, [identifier]);
    useEffect(() => {
        fetch();
    }, [fetch]);
    return { data, loading, error, refetch: fetch };
}
// Hook for workouts
export function useHealthKitWorkouts() {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    const fetch = useCallback(async () => {
        setLoading(true);
        setError(null);
        try {
            const result = await getHealthKitBridge().getWorkoutsGeneric();
            setData(result);
        }
        catch (e) {
            setError((e === null || e === void 0 ? void 0 : e.message) || 'Error fetching data');
        }
        finally {
            setLoading(false);
        }
    }, []);
    useEffect(() => {
        fetch();
    }, [fetch]);
    return { data, loading, error, refetch: fetch };
}
// Hook for available types
export function useHealthKitTypes() {
    const [types, setTypes] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);
    const fetchTypes = useCallback(async () => {
        setLoading(true);
        setError(null);
        try {
            const result = await getHealthKitBridge().getAvailableTypes();
            setTypes(result);
            return result;
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Error fetching available types';
            setError(errorMessage);
            return [];
        }
        finally {
            setLoading(false);
        }
    }, []);
    const getTypeInfo = useCallback(async (identifier) => {
        setLoading(true);
        setError(null);
        try {
            const result = await getHealthKitBridge().getTypeInfo(identifier);
            return result;
        }
        catch (e) {
            const errorMessage = (e === null || e === void 0 ? void 0 : e.message) || 'Error fetching type information';
            setError(errorMessage);
            return null;
        }
        finally {
            setLoading(false);
        }
    }, []);
    return {
        types,
        loading,
        error,
        fetchTypes,
        getTypeInfo
    };
}
// Hook for provider information
export function useHealthKitProvider() {
    const [providerInfo, setProviderInfo] = useState(null);
    const [availableProviders, setAvailableProviders] = useState([]);
    const [allProvidersInfo, setAllProvidersInfo] = useState([]);
    const fetchProviderInfo = useCallback(() => {
        const info = getHealthKitBridge().getProviderInfo();
        const available = getHealthKitBridge().getAvailableProviders();
        const allInfo = getHealthKitBridge().getAllProvidersInfo();
        setProviderInfo(info);
        setAvailableProviders(available);
        setAllProvidersInfo(allInfo);
        return { info, available, allInfo };
    }, []);
    return {
        providerInfo,
        availableProviders,
        allProvidersInfo,
        fetchProviderInfo
    };
}