@kingstinct/react-native-healthkit 4.4.6 → 5.0.0

package/src/utils/queryQuantitySamples.ts

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

package/src/utils/queryStatisticsForQuantity.ts

@@ -0,0 +1,38 @@
+import Native from '../native-types'
+import ensureUnit from './ensureUnit'
+
+import type { HKQuantityTypeIdentifier, HKStatisticsOptions, UnitForIdentifier } from '../native-types'
+
+async function queryStatisticsForQuantity<TIdentifier extends HKQuantityTypeIdentifier, TUnit extends UnitForIdentifier<TIdentifier> = UnitForIdentifier<TIdentifier>>(
+  identifier: TIdentifier,
+  options: readonly HKStatisticsOptions[],
+  from: Date,
+  to?: Date,
+  unit?: TUnit,
+) {
+  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
+}
+
+export default queryStatisticsForQuantity

package/src/utils/queryWorkouts.ts

@@ -0,0 +1,28 @@
+import Native from '../native-types'
+import deserializeWorkout from './deserializeWorkout'
+import getPreferredUnitsTyped from './getPreferredUnitsTyped'
+import prepareOptions from './prepareOptions'
+
+import type { EnergyUnit, LengthUnit } from '../native-types'
+import type { QueryWorkoutsOptions } from '../types'
+
+async function queryWorkouts<
+  TEnergy extends EnergyUnit,
+  TDistance extends LengthUnit
+>(options: QueryWorkoutsOptions<TEnergy, TDistance>) {
+  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)
+}
+
+export default queryWorkouts

package/src/utils/requestAuthorization.ts

@@ -0,0 +1,18 @@
+import Native from '../native-types'
+
+import type {
+  HealthkitReadAuthorization, HealthkitWriteAuthorization, ReadPermissions, WritePermissions,
+} from '../native-types'
+
+const requestAuthorization = async (
+  read: readonly HealthkitReadAuthorization[],
+  write: readonly HealthkitWriteAuthorization[] = [],
+): Promise<boolean> => {
+  const readPermissions = read.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as ReadPermissions)
+
+  const writePermissions = write.reduce((obj, cur) => ({ ...obj, [cur]: true }), {} as WritePermissions)
+
+  return Native.requestAuthorization(writePermissions, readPermissions)
+}
+
+export default requestAuthorization

package/src/utils/saveCategorySample.ts

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

package/src/utils/saveCorrelationSample.ts

@@ -0,0 +1,34 @@
+import Native from '../native-types'
+import ensureMetadata from './ensureMetadata'
+
+import type { MetadataMapperForCorrelationIdentifier, HKCorrelationTypeIdentifier } from '../native-types'
+import type { HKCategorySampleForSaving, HKQuantitySampleForSaving } from '../types'
+
+async 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>;
+  },
+) {
+  const start = (options?.start || new Date()).toISOString()
+  const end = (options?.end || new Date()).toISOString()
+
+  return Native.saveCorrelationSample(
+    typeIdentifier,
+    samples.map((s) => ({ ...s, metadata: ensureMetadata(s.metadata) })),
+    start,
+    end,
+    ensureMetadata(options?.metadata),
+  )
+}
+
+export default saveCorrelationSample

package/src/utils/saveQuantitySample.ts

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

package/src/utils/saveWorkoutSample.ts

@@ -0,0 +1,28 @@
+import Native from '../native-types'
+import ensureMetadata from './ensureMetadata'
+
+import type { HKWorkoutActivityType, HKWorkoutMetadata } from '../native-types'
+import type { HKQuantitySampleForSaving } from '../types'
+
+async function saveWorkoutSample<TIdentifier extends HKWorkoutActivityType>(
+  typeIdentifier: TIdentifier,
+  quantities: readonly HKQuantitySampleForSaving[],
+  _start: Date,
+  options?: {
+    readonly end?: Date;
+    readonly metadata?: HKWorkoutMetadata;
+  },
+) {
+  const start = _start.toISOString()
+  const end = (options?.end || new Date()).toISOString()
+
+  return Native.saveWorkoutSample(
+    typeIdentifier,
+    quantities.map(((s) => ({ ...s, metadata: ensureMetadata(s.metadata) }))),
+    start,
+    end,
+    ensureMetadata(options?.metadata),
+  )
+}
+
+export default saveWorkoutSample

package/src/utils/serializeDate.ts

@@ -0,0 +1,3 @@
+const serializeDate = (date?: Date | null): string => (date ? date.toISOString() : new Date(0).toISOString())
+
+export default serializeDate

package/src/utils/subscribeToChanges.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from '..'
+import Native from '../native-types'
+
+import type { HKSampleTypeIdentifier } from '..'
+
+const subscribeToChanges = async (
+  identifier: HKSampleTypeIdentifier,
+  callback: () => void,
+) => {
+  const subscription = EventEmitter.addListener(
+    'onChange',
+    ({ typeIdentifier }) => {
+      if (typeIdentifier === identifier) {
+        callback()
+      }
+    },
+  )
+
+  const queryId = await Native.subscribeToObserverQuery(identifier).catch(
+    async (error) => {
+      subscription.remove()
+      return Promise.reject(error)
+    },
+  )
+
+  return async () => {
+    subscription.remove()
+    return Native.unsubscribeQuery(queryId)
+  }
+}
+
+export default subscribeToChanges