@kingstinct/react-native-healthkit 4.4.6 → 5.0.0

package/lib/typescript/src/utils/queryCorrelationSamples.d.ts

@@ -0,0 +1,5 @@
+import type { HKCorrelationTypeIdentifier } from '../native-types';
+import type { GenericQueryOptions, HKCorrelation } from '../types';
+export declare type QueryCorrelationSamplesFn = <TIdentifier extends HKCorrelationTypeIdentifier>(typeIdentifier: TIdentifier, options: Omit<GenericQueryOptions, 'ascending' | 'limit'>) => Promise<readonly HKCorrelation<TIdentifier>[]>;
+declare const queryCorrelationSamples: QueryCorrelationSamplesFn;
+export default queryCorrelationSamples;

package/lib/typescript/src/utils/queryQuantitySamples.d.ts

@@ -0,0 +1,7 @@
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types';
+import type { GenericQueryOptions, HKQuantitySample } from '../types';
+export declare type QueryQuantitySamplesFn = <TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier>>(identifier: TIdentifier, options: GenericQueryOptions & {
+    readonly unit?: TUnit;
+}) => Promise<readonly HKQuantitySample<TIdentifier>[]>;
+declare const queryQuantitySamples: QueryQuantitySamplesFn;
+export default queryQuantitySamples;

package/lib/typescript/src/utils/queryStatisticsForQuantity.d.ts

@@ -0,0 +1,14 @@
+import type { HKQuantityTypeIdentifier, HKStatisticsOptions, UnitForIdentifier } from '../native-types';
+declare function queryStatisticsForQuantity<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>>(identifier: TIdentifier, options: readonly HKStatisticsOptions[], from: Date, to?: Date, unit?: TUnit): Promise<{
+    mostRecentQuantityDateInterval?: {
+        from: Date;
+        to: Date;
+    } | undefined;
+    averageQuantity?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, TUnit> | undefined;
+    maximumQuantity?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, TUnit> | undefined;
+    minimumQuantity?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, TUnit> | undefined;
+    sumQuantity?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, TUnit> | undefined;
+    mostRecentQuantity?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, TUnit> | undefined;
+    duration?: import("../native-types").HKQuantity<HKQuantityTypeIdentifier, import("../native-types").TimeUnit> | undefined;
+}>;
+export default queryStatisticsForQuantity;

package/lib/typescript/src/utils/queryWorkouts.d.ts

@@ -0,0 +1,4 @@
+import type { EnergyUnit, LengthUnit } from '../native-types';
+import type { QueryWorkoutsOptions } from '../types';
+declare function queryWorkouts<TEnergy extends EnergyUnit, TDistance extends LengthUnit>(options: QueryWorkoutsOptions<TEnergy, TDistance>): Promise<import("../types").HKWorkout<TEnergy, TDistance>[]>;
+export default queryWorkouts;

package/lib/typescript/src/utils/requestAuthorization.d.ts

@@ -0,0 +1,3 @@
+import type { HealthkitReadAuthorization, HealthkitWriteAuthorization } from '../native-types';
+declare const requestAuthorization: (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => Promise<boolean>;
+export default requestAuthorization;

package/lib/typescript/src/utils/saveCategorySample.d.ts

@@ -0,0 +1,7 @@
+import type { HKCategoryTypeIdentifier, HKCategoryValueForIdentifier, MetadataMapperForCategoryIdentifier } from '../native-types';
+declare function saveCategorySample<T extends HKCategoryTypeIdentifier>(identifier: T, value: HKCategoryValueForIdentifier<T>, options?: {
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForCategoryIdentifier<T>;
+}): Promise<boolean>;
+export default saveCategorySample;

package/lib/typescript/src/utils/saveCorrelationSample.d.ts

@@ -0,0 +1,8 @@
+import type { MetadataMapperForCorrelationIdentifier, HKCorrelationTypeIdentifier } from '../native-types';
+import type { HKCategorySampleForSaving, HKQuantitySampleForSaving } from '../types';
+declare function saveCorrelationSample<TIdentifier extends HKCorrelationTypeIdentifier, TSamples extends readonly (HKCategorySampleForSaving | HKQuantitySampleForSaving)[]>(typeIdentifier: TIdentifier, samples: TSamples, options?: {
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForCorrelationIdentifier<TIdentifier>;
+}): Promise<boolean>;
+export default saveCorrelationSample;

package/lib/typescript/src/utils/saveQuantitySample.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataMapperForQuantityIdentifier, HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types';
+declare function saveQuantitySample<TType extends HKQuantityTypeIdentifier>(identifier: TType, unit: UnitForIdentifier<TType>, value: number, options?: {
+    readonly start?: Date;
+    readonly end?: Date;
+    readonly metadata?: MetadataMapperForQuantityIdentifier<TType>;
+}): Promise<boolean>;
+export default saveQuantitySample;

package/lib/typescript/src/utils/saveWorkoutSample.d.ts

@@ -0,0 +1,7 @@
+import type { HKWorkoutActivityType, HKWorkoutMetadata } from '../native-types';
+import type { HKQuantitySampleForSaving } from '../types';
+declare function saveWorkoutSample<TIdentifier extends HKWorkoutActivityType>(typeIdentifier: TIdentifier, quantities: readonly HKQuantitySampleForSaving[], _start: Date, options?: {
+    readonly end?: Date;
+    readonly metadata?: HKWorkoutMetadata;
+}): Promise<boolean>;
+export default saveWorkoutSample;

package/lib/typescript/src/utils/serializeDate.d.ts

@@ -0,0 +1,2 @@
+declare const serializeDate: (date?: Date | null) => string;
+export default serializeDate;

package/lib/typescript/src/utils/subscribeToChanges.d.ts

@@ -0,0 +1,3 @@
+import type { HKSampleTypeIdentifier } from '..';
+declare const subscribeToChanges: (identifier: HKSampleTypeIdentifier, callback: () => void) => Promise<() => Promise<boolean>>;
+export default subscribeToChanges;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "4.4.6",
+  "version": "5.0.0",
   "description": "React Native bindings for HealthKit",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -20,7 +20,8 @@
     "!**/__mocks__"
   ],
   "scripts": {
-    "test": "jest",
+    "test-only": "jest",
+    "test": "concurrently \"yarn test-only\" \"yarn typecheck\" \"yarn lint\"",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "prepare": "bob build",
@@ -44,6 +45,7 @@
   },
   "homepage": "https://github.com/kingstinct/react-native-healthkit#readme",
   "devDependencies": {
+    "@babel/core": ">=7",
     "@commitlint/config-conventional": "12",
     "@graphql-eslint/eslint-plugin": ">=3",
     "@release-it/conventional-changelog": "2",
@@ -52,20 +54,28 @@
     "@types/react-native": "0.67",
     "@typescript-eslint/eslint-plugin": ">=5",
     "@typescript-eslint/parser": ">=5",
-    "commitlint": "12",
+    "commitlint": "^17.1.1",
+    "concurrently": "^7.3.0",
     "eslint": ">=8",
+    "eslint-config-airbnb": ">=19",
     "eslint-config-airbnb-base": ">=15",
-    "eslint-config-kingstinct": "5.1.1",
+    "eslint-config-kingstinct": "^5.1.1",
     "eslint-import-resolver-typescript": ">=3",
     "eslint-plugin-comment-length": ">=0",
     "eslint-plugin-functional": ">=4",
     "eslint-plugin-import": ">=2",
     "eslint-plugin-jest": ">=26",
     "eslint-plugin-jsonc": ">=2",
+    "eslint-plugin-jsx-a11y": ">=6",
+    "eslint-plugin-react": ">=7",
+    "eslint-plugin-react-hooks": ">=4",
+    "eslint-plugin-react-native": ">=4",
+    "eslint-plugin-react-native-a11y": ">=3",
     "eslint-plugin-unicorn": ">=43",
     "eslint-plugin-yml": ">=1",
+    "expo": ">=45",
     "graphql": ">=16",
-    "husky": "^4.2.5",
+    "husky": "8",
     "jest": ">=26",
     "metro-react-native-babel-preset": "^0.70.3",
     "pod-install": "^0.1.0",
@@ -114,7 +124,8 @@
     },
     "plugins": {
       "@release-it/conventional-changelog": {
-        "preset": "angular"
+        "preset": "angular",
+        "infile": "CHANGELOG.md"
       }
     }
   },

package/src/hooks/useHealthkitAuthorization.ts

@@ -0,0 +1,39 @@
+import {
+  useCallback, useEffect, useRef, useState,
+} from 'react'
+
+import getRequestStatusForAuthorization from '../utils/getRequestStatusForAuthorization'
+import requestAuthorization from '../utils/requestAuthorization'
+
+import type { HealthkitReadAuthorization, HealthkitWriteAuthorization, HKAuthorizationRequestStatus } from '../native-types'
+
+const useHealthkitAuthorization = (read: readonly HealthkitReadAuthorization[], write?: readonly HealthkitWriteAuthorization[]) => {
+  const [status, setStatus] = useState<HKAuthorizationRequestStatus | null>(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 getRequestStatusForAuthorization(readMemo.current, writeMemo.current)
+    setStatus(auth)
+    return auth
+  }, [])
+
+  const request = useCallback(async () => {
+    await requestAuthorization(readMemo.current, writeMemo.current)
+    return refreshAuthStatus()
+  }, [refreshAuthStatus])
+
+  useEffect(() => {
+    void refreshAuthStatus()
+  }, [refreshAuthStatus])
+
+  return [status, request] as const
+}
+
+export default useHealthkitAuthorization

package/src/hooks/useIsHealthDataAvailable.ts

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react'
+
+import Native from '../native-types'
+
+const useIsHealthDataAvailable = () => {
+  const [isAvailable, setIsAvailable] = useState<boolean | null>(null)
+  useEffect(() => {
+    const init = async () => {
+      const res = await Native.isHealthDataAvailable()
+      setIsAvailable(res)
+    }
+    void init()
+  }, [])
+  return isAvailable
+}
+
+export default useIsHealthDataAvailable

package/src/hooks/useMostRecentCategorySample.ts

@@ -0,0 +1,24 @@
+import { useCallback, useState } from 'react'
+
+import getMostRecentCategorySample from '../utils/getMostRecentCategorySample'
+import useSubscribeToChanges from './useSubscribeToChanges'
+
+import type { HKCategoryTypeIdentifier } from '../native-types'
+import type { HKCategorySample } from '../types'
+
+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
+}
+
+export default useMostRecentCategorySample

package/src/hooks/useMostRecentQuantitySample.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react'
+
+import ensureUnit from '../utils/ensureUnit'
+import getMostRecentQuantitySample from '../utils/getMostRecentQuantitySample'
+import subscribeToChanges from '../utils/subscribeToChanges'
+
+import type { HKQuantityTypeIdentifier, UnitForIdentifier } from '../native-types'
+import type { HKQuantitySample } from '../types'
+
+function useMostRecentQuantitySample<
+  TIdentifier extends HKQuantityTypeIdentifier,
+  TUnit extends UnitForIdentifier<TIdentifier>
+>(identifier: TIdentifier, unit?: TUnit) {
+  const [lastSample, setLastSample] = useState<HKQuantitySample<
+  TIdentifier
+  > | null>(null)
+
+  useEffect(() => {
+    let cancelSubscription: (() => Promise<boolean>) | undefined
+
+    const init = async () => {
+      const actualUnit = await ensureUnit(identifier, unit)
+
+      cancelSubscription = await subscribeToChanges(identifier, async () => {
+        const value = await getMostRecentQuantitySample(identifier, actualUnit)
+        setLastSample(value)
+      })
+    }
+    void init()
+
+    return () => {
+      void cancelSubscription?.()
+    }
+  }, [identifier, unit])
+
+  return lastSample
+}
+
+export default useMostRecentQuantitySample

package/src/hooks/useMostRecentWorkout.ts

@@ -0,0 +1,60 @@
+import {
+  useEffect, useState, useRef, useCallback,
+} from 'react'
+
+import getMostRecentWorkout from '../utils/getMostRecentWorkout'
+import getPreferredUnitsTyped from '../utils/getPreferredUnitsTyped'
+import subscribeToChanges from '../utils/subscribeToChanges'
+
+import type { EnergyUnit, LengthUnit } from '../native-types'
+import type { HKWorkout } from '../types'
+
+function useMostRecentWorkout<
+  TEnergy extends EnergyUnit,
+  TDistance extends LengthUnit
+>(options?: { readonly energyUnit?: TEnergy; readonly distanceUnit?: TDistance }) {
+  const [workout, setWorkout] = useState<HKWorkout<TEnergy, TDistance> | null>(null)
+
+  const optionsRef = useRef(options)
+
+  useEffect(() => {
+    optionsRef.current = options
+  }, [options])
+
+  const update = useCallback(async () => {
+    const { energyUnit, distanceUnit } = await getPreferredUnitsTyped(
+      optionsRef.current,
+    )
+
+    console.log({ energyUnit, distanceUnit })
+
+    setWorkout(await getMostRecentWorkout({
+      energyUnit,
+      distanceUnit,
+    }))
+  }, [])
+
+  useEffect(() => {
+    void update()
+  }, [update])
+
+  useEffect(() => {
+    let cancelSubscription: (() => Promise<boolean>) | undefined
+
+    const init = async () => {
+      cancelSubscription = await subscribeToChanges(
+        'HKWorkoutTypeIdentifier',
+        update,
+      )
+    }
+    void init()
+
+    return () => {
+      void cancelSubscription?.()
+    }
+  }, [update])
+
+  return workout
+}
+
+export default useMostRecentWorkout

package/src/hooks/useStatisticsForQuantity.ts

@@ -0,0 +1,42 @@
+import {
+  useState, useEffect, useCallback, useRef,
+} from 'react'
+
+import queryStatisticsForQuantity from '../utils/queryStatisticsForQuantity'
+import useSubscribeToChanges from './useSubscribeToChanges'
+
+import type { HKQuantityTypeIdentifier, HKStatisticsOptions, UnitForIdentifier } from '../native-types'
+import type { QueryStatisticsResponse } from '../types'
+
+function useStatisticsForQuantity<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>>(
+  identifier: TIdentifier,
+  options: readonly HKStatisticsOptions[],
+  from: Date,
+  to?: Date,
+  unit?: TUnit,
+) {
+  const [result, setResult] = useState<QueryStatisticsResponse<TIdentifier, TUnit> | null>(null)
+
+  const optionsRef = useRef(options)
+
+  useEffect(() => {
+    optionsRef.current = options
+  }, [options])
+
+  const update = useCallback(async () => {
+    const res = await queryStatisticsForQuantity(identifier, optionsRef.current, from, to, unit)
+    setResult(res)
+  }, [
+    identifier, from, to, unit,
+  ])
+
+  useEffect(() => {
+    void update()
+  }, [update])
+
+  useSubscribeToChanges(identifier, update)
+
+  return result
+}
+
+export default useStatisticsForQuantity

package/src/hooks/useSubscribeToChanges.ts

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from 'react'
+
+import subscribeToChanges from '../utils/subscribeToChanges'
+
+import type { HKSampleTypeIdentifier } from '..'
+
+function useSubscribeToChanges<TIdentifier extends HKSampleTypeIdentifier>(
+  identifier: TIdentifier,
+  onChange: () => void,
+): void {
+  const onChangeRef = useRef(onChange)
+
+  useEffect(() => {
+    onChangeRef.current = onChange
+  }, [onChange])
+
+  useEffect(() => {
+    let cancelSubscription: (() => Promise<boolean>) | undefined
+
+    const init = async () => {
+      cancelSubscription = await subscribeToChanges(identifier, onChangeRef.current)
+    }
+    void init()
+
+    return () => {
+      void cancelSubscription?.()
+    }
+  }, [identifier])
+}
+
+export default useSubscribeToChanges