@kingstinct/react-native-healthkit 8.7.2 → 9.0.0

package/ios/WorkoutsModule.swift

@@ -0,0 +1,357 @@
+import HealthKit
+import CoreLocation
+import NitroModules
+
+#if canImport(WorkoutKit)
+import WorkoutKit
+#endif
+
+/*func tryParseWeatherCondition(_ weatherCondition: Int?) -> WeatherCondition? {
+    if let weatherCondition = weatherCondition {
+        return WeatherCondition.init(rawValue: Int32(weatherCondition))
+    }
+    return nil
+}
+
+func deserializeWorkoutMetadata(_ metadata: WorkoutMetadata?) -> [String: Any]? {
+    if let metadata = metadata {
+        var dict = metadata.allMetadata != nil
+        ? anyMapToDictionary(metadata.allMetadata!)
+        : Dictionary<String, Any>()
+        // todo (important): hmm, not sure about the typed props here
+        // dict[""]
+        return dict
+    }
+    return nil
+}
+
+func serializeWorkoutMetadata(_ metadata: [String: Any]?) -> WorkoutMetadata? {
+    if let metadata = metadata {
+        return WorkoutMetadata(
+            // todo: figure out conversions here
+            HKWeatherCondition: tryParseWeatherCondition(metadata["HKWeatherCondition"] as? Int),
+            HKWeatherHumidity: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherHumidity"] as? HKQuantity),
+            HKWeatherTemperature: serializeUnknownQuantityTyped(quantity: metadata["HKWeatherTemperature"] as? HKQuantity),
+            HKAverageMETs: serializeUnknownQuantityTyped(quantity: metadata["HKAverageMETs"] as? HKQuantity),
+            HKElevationAscended: serializeUnknownQuantityTyped(quantity: metadata["HKElevationAscended"] as? HKQuantity),
+            HKIndoorWorkout: metadata["HKIndoorWorkout"] as? Bool,
+            HKExternalUUID: metadata["HKExternalUUID"] as? String,
+            HKTimeZone: metadata["HKTimeZone"] as? String,
+            HKWasUserEntered: metadata["HKWasUserEntered"] as? Bool,
+            HKDeviceSerialNumber: metadata["HKDeviceSerialNumber"] as? String,
+            HKUDIDeviceIdentifier: metadata["HKUDIDeviceIdentifier"] as? String,
+            HKUDIProductionIdentifier: metadata["HKUDIProductionIdentifier"] as? String,
+            HKDigitalSignature: metadata["HKDigitalSignature"] as? String,
+            HKDeviceName: metadata["HKDeviceName"] as? String,
+            HKDeviceManufacturerName: metadata["HKDeviceManufacturerName"] as? String,
+            HKSyncIdentifier: metadata["HKSyncIdentifier"] as? String,
+            HKSyncVersion: metadata["HKSyncVersion"] as? Double,
+            HKWasTakenInLab: metadata["HKWasTakenInLab"] as? Bool,
+            HKReferenceRangeLowerLimit: metadata["HKReferenceRangeLowerLimit"] as? Double,
+            HKReferenceRangeUpperLimit: metadata["HKReferenceRangeUpperLimit"] as? Double,
+            allMetadata: serializeAllMetadata(metadata)
+        )
+    }
+    return nil
+}*/
+
+func mapLocations(from locations: [LocationForSaving]) -> [CLLocation] {
+    return locations.compactMap { location in
+        let latitude = location.latitude
+        let longitude = location.longitude
+        let altitude = location.altitude
+        let horizontalAccuracy = location.horizontalAccuracy
+        let verticalAccuracy = location.verticalAccuracy
+        let course = location.course
+        let speed = location.speed
+        let timestamp = location.date
+        
+        let clLocation = CLLocation(
+            coordinate: CLLocationCoordinate2D(
+                latitude: latitude,
+                longitude: longitude
+            ),
+            altitude: altitude,
+            horizontalAccuracy: horizontalAccuracy,
+            verticalAccuracy: verticalAccuracy,
+            course: course,
+            speed: speed,
+            timestamp: timestamp,
+        )
+        
+        return clLocation
+    }
+}
+
+class WorkoutsModule : HybridWorkoutsModuleSpec {
+    func queryWorkoutSamples(options: WorkoutQueryOptions) throws -> Promise<[HybridWorkoutProxySpec]> {
+        let predicate = try createPredicateForWorkout(filter: options.filter)
+        
+        let limit = getQueryLimit(options.limit)
+        
+        return Promise.async {
+            let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
+            
+            let distanceUnit = try await getUnitToUse(unitOverride: options.distanceUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
+            
+            return try await withCheckedThrowingContinuation { continuation in
+                let q = HKSampleQuery(
+                    sampleType: .workoutType(),
+                    predicate: predicate,
+                    limit: limit,
+                    sortDescriptors: getSortDescriptors(ascending: options.ascending ?? true)
+                ) { (_: HKSampleQuery, samples: [HKSample]?, error: Error?) in
+                    if let error = error {
+                        return continuation.resume(throwing: error)
+                    }
+                    
+                    guard let samples = samples else {
+                        return continuation.resume(throwing: RuntimeError.error(withMessage: "Empty response"))
+                    }
+                    
+                    let workoutProxies = samples.compactMap { s in
+                        if let workout = s as? HKWorkout {
+                            return WorkoutProxy.init(
+                                workout: workout,
+                                distanceUnit: distanceUnit,
+                                energyUnit: energyUnit
+                            )
+                        }
+                        return nil
+                    }
+                    
+                    return continuation.resume(returning: workoutProxies)
+                }
+                
+                store.execute(q)
+            }
+        }
+    }
+    
+    func saveWorkoutSample(
+        workoutActivityType: WorkoutActivityType,
+        quantities: [QuantitySampleForSaving],
+        startDate: Date,
+        endDate: Date,
+        totals: WorkoutTotals,
+        metadata: AnyMapHolder
+    ) throws -> Promise<String> {
+        
+        let type = try initializeWorkoutActivityType(UInt(workoutActivityType.rawValue))
+        
+        // if start and end both exist,  ensure that start date is before end date
+        if let startDate = startDate as Date?, let endDate = endDate as Date? {
+            if startDate > endDate {
+                throw RuntimeError.error(withMessage: "endDate must not be less than startDate")
+            }
+        }
+        
+        let metadataDeserialized = anyMapToDictionary(metadata)
+        
+        var totalEnergyBurned: HKQuantity?
+        var totalDistance: HKQuantity?
+        var totalSwimmingStrokeCount: HKQuantity?
+        var totalFlightsClimbed: HKQuantity?
+        // generating quantity samples
+        let initializedSamples = try quantities.map { quantity in
+            let type = try initializeQuantityType(quantity.quantityType.stringValue)
+            let unitStr = quantity.unit
+            let quantityVal = quantity.quantity
+            let quantityStart = quantity.startDate
+            let quantityEnd = quantity.endDate
+            let unit = HKUnit.init(from: unitStr)
+            let quantity = HKQuantity.init(unit: unit, doubleValue: quantityVal)
+            
+            if quantity.is(compatibleWith: HKUnit.kilocalorie()) {
+                totalEnergyBurned = quantity
+            }
+            
+            if quantity.is(compatibleWith: HKUnit.meter()) {
+                totalDistance = quantity
+            }
+            
+            if type.identifier == HKWorkoutSortIdentifierTotalSwimmingStrokeCount {
+                totalSwimmingStrokeCount = quantity
+            }
+            
+            if type.identifier == HKWorkoutSortIdentifierTotalFlightsClimbed {
+                totalFlightsClimbed = quantity
+            }
+            
+            return HKQuantitySample.init(
+                type: type,
+                quantity: quantity,
+                start: quantityStart,
+                end: quantityEnd,
+                metadata: metadataDeserialized
+            )
+        }
+        
+        // if totals are provided override samples
+        let rawTotalDistance = totals.distance ?? 0.0
+        let rawTotalEnergy = totals.energyBurned ?? 0.0
+        
+        if rawTotalDistance != 0.0 {
+            totalDistance = HKQuantity(unit: .meter(), doubleValue: rawTotalDistance)
+        }
+        if rawTotalEnergy != 0.0 {
+            totalEnergyBurned = HKQuantity(unit: .kilocalorie(), doubleValue: rawTotalEnergy)
+        }
+        
+        // creating workout
+        var workout: HKWorkout?
+        
+        if totalSwimmingStrokeCount != nil {
+            workout = HKWorkout.init(
+                activityType: type,
+                start: startDate,
+                end: endDate,
+                workoutEvents: nil,
+                totalEnergyBurned: totalEnergyBurned,
+                totalDistance: totalDistance,
+                totalSwimmingStrokeCount: totalSwimmingStrokeCount,
+                device: nil,
+                metadata: metadataDeserialized
+            )
+        } else {
+            if #available(iOS 11, *) {
+                if totalFlightsClimbed != nil {
+                    workout = HKWorkout.init(
+                        activityType: type,
+                        start: startDate,
+                        end: endDate,
+                        workoutEvents: nil,
+                        totalEnergyBurned: totalEnergyBurned,
+                        totalDistance: totalDistance,
+                        totalFlightsClimbed: totalFlightsClimbed,
+                        device: nil,
+                        metadata: metadataDeserialized
+                    )
+                }
+            }
+        }
+        
+        if workout == nil {
+            workout = HKWorkout.init(
+                activityType: type,
+                start: startDate,
+                end: endDate,
+                workoutEvents: nil,
+                totalEnergyBurned: totalEnergyBurned,
+                totalDistance: totalDistance,
+                metadata: metadataDeserialized
+            )
+        }
+        
+        guard let workout = workout else {
+            throw RuntimeError.error(withMessage: "Could not create workout")
+        }
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                // saving workout, samples and route
+                store.save(workout) { (_: Bool, error: Error?) in
+                    if let error = error {
+                        return continuation.resume(throwing: error)
+                    }
+                    
+                    if initializedSamples.isEmpty {
+                        return continuation.resume(returning: workout.uuid.uuidString)
+                    }
+                    
+                    store.add(initializedSamples, to: workout) { (_, error: Error?) in
+                        if let error = error {
+                            return continuation.resume(throwing: error)
+                        }
+                        return continuation.resume(returning: workout.uuid.uuidString)
+                    }
+                }
+            }
+        }
+    }
+    
+    
+    func startWatchAppWithWorkoutConfiguration(workoutConfiguration: WorkoutConfiguration) -> Promise<Bool>
+    {
+        let configuration = parseWorkoutConfiguration(workoutConfiguration)
+        
+        return Promise.async {
+            try await withCheckedThrowingContinuation { continuation in
+                store.startWatchApp(with: configuration) { success, error in
+                    if let error {
+                        continuation.resume(throwing: error)
+                    } else {
+                        continuation.resume(returning: success)
+                    }
+                }
+            }
+        }
+    }
+    
+    func queryWorkoutSamplesWithAnchor(options: WorkoutQueryOptionsWithAnchor) throws -> Promise<QueryWorkoutSamplesWithAnchorResponse> {
+        let predicate = try createPredicateForWorkout(filter: options.filter)
+        
+        let limit = getQueryLimit(options.limit)
+        
+        let actualAnchor = try deserializeHKQueryAnchor(base64String: options.anchor)
+        
+        return Promise.async {
+            let energyUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.activeEnergyBurned))
+            
+            let distanceUnit = try await getUnitToUse(unitOverride: options.energyUnit, quantityType: HKQuantityType(.distanceWalkingRunning))
+            
+            return try await withCheckedThrowingContinuation { continuation in
+                let q = HKAnchoredObjectQuery(
+                    type: .workoutType(),
+                    predicate: predicate,
+                    anchor: actualAnchor,
+                    limit: limit
+                ) {
+                    (
+                        _: HKAnchoredObjectQuery,
+                        s: [HKSample]?,
+                        deletedSamples: [HKDeletedObject]?,
+                        newAnchor: HKQueryAnchor?,
+                        error: Error?
+                    ) in
+                    if let error = error {
+                        return continuation.resume(throwing: error)
+                    }
+                    
+                    guard let samples = s, let newAnchor = newAnchor else {
+                        return continuation.resume(
+                            throwing: RuntimeError.error(
+                                withMessage: "Empty response"
+                            )
+                        )
+                    }
+                    
+                    let workoutProxies = samples.compactMap { s in
+                        if let workout = s as? HKWorkout {
+                            return WorkoutProxy.init(
+                                workout: workout,
+                                distanceUnit: distanceUnit,
+                                energyUnit: energyUnit
+                            )
+                        }
+                        return nil
+                    }
+                    
+                    let deletedSamples = deletedSamples?.map({ sample in
+                        return serializeDeletedSample(sample: sample)
+                    }) ?? []
+                    
+                    let returnValue = QueryWorkoutSamplesWithAnchorResponse(
+                        workouts: workoutProxies,
+                        deletedSamples: deletedSamples,
+                        newAnchor: serializeAnchor(anchor: newAnchor)!
+                    )
+                    
+                    return continuation.resume(returning: returnValue)
+                }
+                
+                store.execute(q)
+            }
+        }
+    }
+}

package/package.json

@@ -1,152 +1,68 @@
 {
   "name": "@kingstinct/react-native-healthkit",
-  "version": "8.7.2",
+  "version": "9.0.0",
   "description": "React Native bindings for HealthKit",
-  "main": "lib/commonjs/index",
-  "module": "lib/module/index",
-  "types": "lib/typescript/src/index.d.ts",
+  "main": "lib/index",
+  "module": "lib/index",
+  "types": "lib/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
   "files": [
     "src",
+    "react-native.config.js",
     "lib",
-    "ios",
-    "cpp",
-    "kingstinct-react-native-healthkit.podspec",
-    "!lib/typescript/example",
-    "!**/__tests__",
-    "!**/__fixtures__",
-    "!**/__mocks__",
-    "app.plugin.js"
+    "nitrogen/**/*",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "*.podspec",
+    "README.md"
   ],
   "scripts": {
-    "test-only": "bun test --preload ./src/test-setup.ts src",
-    "test": "concurrently \"bun test-only\" \"bun typecheck\" \"bun lint\"",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint \"**/*.{js,ts,tsx}\" --cache",
-    "prepare": "bob build && husky install",
-    "release": "release-it",
-    "pods": "cd example && pod-install --quiet",
-    "bootstrap": "cd example && bun install && bun pods",
-    "upgrade-interactive": "bunx npm-check-updates --format group -i"
+    "lint": "bunx @biomejs/biome format --write",
+    "typescript": "tsc",
+    "codegen": "tsc && nitro-codegen --logLevel=\"debug\"",
+    "test": "bun test"
   },
-  "lint-staged": {
-    "*.swift": "swiftlint ios --fix",
-    "*.ts": "eslint --fix",
-    "*.js": "eslint --fix",
-    "*.json": "eslint --fix"
+  "keywords": ["react-native", "nitro", "healthkit", "ios", "typescript"],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/kingstinct"
   },
-  "keywords": [
-    "react-native",
-    "ios",
-    "healthkit",
-    "typescript",
-    "react-hooks"
-  ],
-  "repository": "https://github.com/kingstinct/react-native-healthkit",
-  "funding": [
-    "https://github.com/sponsors/kingstinct",
-    "https://github.com/sponsors/robertherber"
-  ],
-  "author": {
-    "name": "Robert Herber",
-    "email": "robert@kingstinct.com",
-    "url": "https://github.com/robertherber"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kingstinct/react-native-healthkit.git"
   },
+  "author": "Robert Herber <robert@kingstinct.com> (https://github.com/robertherber)",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/kingstinct/react-native-healthkit/issues"
   },
   "homepage": "https://github.com/kingstinct/react-native-healthkit#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
   "devDependencies": {
-    "@babel/core": ">=7",
-    "@babel/preset-env": "^7.18.10",
-    "@commitlint/config-conventional": "12",
-    "@expo/config-plugins": "^6.0.1",
-    "@graphql-eslint/eslint-plugin": ">=3",
-    "@release-it/conventional-changelog": "2",
-    "@testing-library/react-native": "12",
-    "@types/bun": "^1.1.3",
-    "@types/node": "^18.7.14",
-    "@types/react": "~18.0.27",
-    "@typescript-eslint/eslint-plugin": "7",
-    "@typescript-eslint/parser": "7",
-    "commitlint": "^17.1.1",
-    "concurrently": "8",
-    "eslint": "8",
-    "eslint-config-airbnb": "19",
-    "eslint-config-airbnb-base": "15",
-    "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": "50",
-    "eslint-plugin-yml": "1",
-    "expo": ">=45",
-    "graphql": ">=16",
-    "husky": "8",
-    "lint-staged": "^13.2.2",
-    "metro-react-native-babel-preset": "^0.70.3",
-    "pod-install": "^0.1.0",
-    "react": "18.2.0",
-    "react-native": "0.71.8",
-    "react-native-builder-bob": "^0.18.1",
-    "react-test-renderer": "18",
-    "release-it": "14",
-    "solidarity": "^3.0.4",
-    "solidarity-react-native": "^2.1.2",
-    "typescript": "^5.8.3"
+    "@testing-library/react-native": "^13.2.0",
+    "@types/react": "~19.0.14",
+    "nitro-codegen": "^0.26.2",
+    "react": "19.0.0",
+    "react-native": "^0.79.3",
+    "react-native-nitro-modules": "^0.26.2",
+    "typescript": "~5.8.3"
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "release-it": {
-    "git": {
-      "commitMessage": "chore: release ${version}",
-      "tagName": "v${version}"
-    },
-    "npm": {
-      "publish": true
-    },
-    "github": {
-      "release": true
-    },
-    "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": "angular",
-        "infile": "CHANGELOG.md"
-      }
-    }
-  },
-  "eslintIgnore": [
-    "node_modules/",
-    "lib/"
-  ],
-  "react-native-builder-bob": {
-    "source": "src",
-    "output": "lib",
-    "targets": [
-      "commonjs",
-      "module",
-      "typescript"
-    ]
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
   }
 }

package/react-native.config.js

@@ -0,0 +1,16 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+
+module.exports = {
+  dependency: {
+    platforms: {
+      /**
+       * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+       */
+      ios: {},
+      /**
+       * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+       */
+      android: {},
+    },
+  },
+}

package/src/hooks/useHealthkitAuthorization.test.ts

@@ -1,65 +1,83 @@
-import { renderHook, act } from '@testing-library/react-native'
+import { beforeAll, describe, expect, jest, test } from 'bun:test'
 
+import { act, renderHook } from '@testing-library/react-native'
+
+import { Core } from '../modules'
 import waitForNextUpdate from '../test-utils'
+import { AuthorizationRequestStatus } from '../types/Auth'
+import type UseHealthkitAuthorization from './useHealthkitAuthorization'
 
 describe('useHealthkitAuthorization', () => {
-  let NativeTypes: typeof import('../native-types')
-  let useHealthkitAuthorization: typeof import('./useHealthkitAuthorization').default
+  let useHealthkitAuthorization: typeof UseHealthkitAuthorization
+
   beforeAll(async () => {
-    NativeTypes = await import('../native-types')
-    useHealthkitAuthorization = (await import('./useHealthkitAuthorization')).default
+    useHealthkitAuthorization = (await import('./useHealthkitAuthorization'))
+      .default
   })
 
   test('should return shouldRequest', async () => {
-    const { HKAuthorizationRequestStatus, HKCategoryTypeIdentifier, default: Native } = NativeTypes
+    jest
+      .spyOn(Core, 'getRequestStatusForAuthorization')
+      .mockReturnValue(
+        Promise.resolve(AuthorizationRequestStatus.shouldRequest),
+      )
 
-    jest.spyOn(Native, 'getRequestStatusForAuthorization').mockReturnValue(Promise.resolve(HKAuthorizationRequestStatus.shouldRequest))
-
-    const { result } = renderHook(() => useHealthkitAuthorization([HKCategoryTypeIdentifier.abdominalCramps]))
+    const { result } = renderHook(() =>
+      useHealthkitAuthorization(['HKCategoryTypeIdentifierAbdominalCramps']),
+    )
 
     await waitForNextUpdate()
 
-    expect(result.current[0]).toBe(HKAuthorizationRequestStatus.shouldRequest)
+    expect(result.current[0]).toBe(AuthorizationRequestStatus.shouldRequest)
   })
 
   test('should request permissions', async () => {
-    const { HKAuthorizationRequestStatus, HKCategoryTypeIdentifier, default: Native } = NativeTypes
-
-    const spy = jest.spyOn(Native, 'getRequestStatusForAuthorization').mockReturnValue(Promise.resolve(HKAuthorizationRequestStatus.shouldRequest))
-    jest.spyOn(Native, 'requestAuthorization').mockReturnValue(Promise.resolve(true))
-
-    const { result } = renderHook(() => useHealthkitAuthorization([HKCategoryTypeIdentifier.abdominalCramps]))
+    const spy = jest
+      .spyOn(Core, 'getRequestStatusForAuthorization')
+      .mockReturnValue(
+        Promise.resolve(AuthorizationRequestStatus.shouldRequest),
+      )
+    jest
+      .spyOn(Core, 'requestAuthorization')
+      .mockReturnValue(Promise.resolve(true))
+
+    const { result } = renderHook(() =>
+      useHealthkitAuthorization(['HKCategoryTypeIdentifierAbdominalCramps']),
+    )
 
     await waitForNextUpdate()
 
-    spy.mockReturnValue(Promise.resolve(HKAuthorizationRequestStatus.unnecessary))
+    spy.mockReturnValue(Promise.resolve(AuthorizationRequestStatus.unnecessary))
 
-    let retVal: typeof HKAuthorizationRequestStatus | undefined
+    let retVal: AuthorizationRequestStatus | undefined
     await act(async () => {
-      const r = await result.current[1]() as unknown as typeof HKAuthorizationRequestStatus
+      const r =
+        (await result.current[1]()) as unknown as AuthorizationRequestStatus
       retVal = r
     })
 
-    expect(result.current[0]).toBe(HKAuthorizationRequestStatus.unnecessary)
-    expect(retVal).toBe(HKAuthorizationRequestStatus.unnecessary)
+    expect(result.current[0]).toBe(AuthorizationRequestStatus.unnecessary)
+    expect(retVal).toBe(AuthorizationRequestStatus.unnecessary)
   })
 
   test('should return unnecessary', async () => {
-    const { HKAuthorizationRequestStatus, HKCategoryTypeIdentifier, default: Native } = NativeTypes
-
-    jest.spyOn(Native, 'getRequestStatusForAuthorization').mockReturnValue(Promise.resolve(HKAuthorizationRequestStatus.unnecessary))
+    jest
+      .spyOn(Core, 'getRequestStatusForAuthorization')
+      .mockReturnValue(Promise.resolve(AuthorizationRequestStatus.unnecessary))
 
-    const { result } = renderHook(() => useHealthkitAuthorization([HKCategoryTypeIdentifier.abdominalCramps]))
+    const { result } = renderHook(() =>
+      useHealthkitAuthorization(['HKCategoryTypeIdentifierAbdominalCramps']),
+    )
 
     await waitForNextUpdate()
 
-    expect(result.current[0]).toBe(HKAuthorizationRequestStatus.unnecessary)
+    expect(result.current[0]).toBe(AuthorizationRequestStatus.unnecessary)
   })
 
   test('should return null before initalizing', async () => {
-    const { HKCategoryTypeIdentifier } = NativeTypes
-
-    const { result } = renderHook(() => useHealthkitAuthorization([HKCategoryTypeIdentifier.abdominalCramps]))
+    const { result } = renderHook(() =>
+      useHealthkitAuthorization(['HKCategoryTypeIdentifierAbdominalCramps']),
+    )
 
     expect(result.current[0]).toBe(null)