@interval-health/capacitor-health 1.0.3 → 1.1.1

package/README.md

@@ -173,7 +173,8 @@ export type HealthDataType =
   | 'mobility' 
   | 'activity' 
   | 'heart' 
-  | 'body';
+  | 'body'
+  | 'workout';
 ```
 
 | Data Type | Description | Unit | iOS | Android | Read | Write |
@@ -188,12 +189,13 @@ export type HealthDataType =
 | `activity` | Activity metrics | mixed | ✅ | ❌ | ✅ | ❌ |
 | `heart` | Heart health metrics | mixed | ✅ | ❌ | ✅ | ❌ |
 | `body` | Body measurements | mixed | ✅ | ❌ | ✅ | ❌ |
+| `workout` | Workout/exercise sessions | minute | ✅ | ❌ | ✅ | ❌ |
 
 **Platform Support Notes**:
-- **iOS** supports all 10 data types
+- **iOS** supports all 11 data types
 - **Android** supports only 5 basic data types: `steps`, `distance`, `calories`, `heartRate`, and `weight`
-- The `sleep`, `mobility`, `activity`, `heart`, and `body` types are **iOS-only** and not available on Android
-- Composite types (`mobility`, `activity`, `heart`, `body`) are **read-only** on iOS
+- The `sleep`, `mobility`, `activity`, `heart`, `body`, and `workout` types are **iOS-only** and not available on Android
+- Composite types (`mobility`, `activity`, `heart`, `body`, `workout`) are **read-only** on iOS
 
 ### Sleep States
 
@@ -209,6 +211,55 @@ When reading sleep data, each sample may include a `sleepState` property:
 | `asleepREM` | REM (Rapid Eye Movement) sleep stage |
 | `unknown` | Sleep state could not be determined |
 
+### Workout Data
+
+When reading workout data (`dataType: 'workout'`), the returned data structure includes:
+
+```typescript
+interface WorkoutData {
+  date: string;           // ISO date (YYYY-MM-DD)
+  type: string;           // Activity type (e.g., "Running", "Cycling", "Swimming")
+  duration: number;       // Duration in minutes
+  distance?: number;      // Distance in miles (optional)
+  calories?: number;      // Calories burned (optional)
+  source?: string;        // Source app name (optional)
+  avgHeartRate?: number;  // Average heart rate in BPM (optional)
+  maxHeartRate?: number;  // Maximum heart rate in BPM (optional)
+  zones?: {               // Heart rate zones in minutes (optional)
+    zone1?: number;       // 50-60% max HR
+    zone2?: number;       // 60-70% max HR
+    zone3?: number;       // 70-80% max HR
+    zone4?: number;       // 80-90% max HR
+    zone5?: number;       // 90-100% max HR
+  };
+}
+```
+
+**Supported Workout Types**: Running, Cycling, Walking, Swimming, Yoga, FunctionalStrengthTraining, TraditionalStrengthTraining, Elliptical, Rowing, Hiking, HighIntensityIntervalTraining, Dance, Basketball, Soccer, Tennis, Golf, StairClimbing, and more.
+
+**Example**:
+```typescript
+const result = await Health.readSamples({
+  dataType: 'workout',
+  startDate: '2024-01-01T00:00:00Z',
+  endDate: '2024-01-31T23:59:59Z',
+  limit: 50
+});
+
+// Sample output:
+// {
+//   date: "2024-01-15",
+//   type: "Running",
+//   duration: 45,
+//   distance: 5.23,
+//   calories: 450,
+//   source: "Apple Watch",
+//   avgHeartRate: 145,
+//   maxHeartRate: 175,
+//   zones: { zone2: 10, zone3: 20, zone4: 15 }
+// }
+```
+
 ---
 
 ## 🔧 Methods

package/android/src/main/java/app/capgo/plugin/health/HealthDataType.kt

@@ -3,6 +3,7 @@ package app.capgo.plugin.health
 import androidx.health.connect.client.permission.HealthPermission
 import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
 import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.ExerciseSessionRecord
 import androidx.health.connect.client.records.HeartRateRecord
 import androidx.health.connect.client.records.Record
 import androidx.health.connect.client.records.SleepSessionRecord
@@ -21,7 +22,8 @@ enum class HealthDataType(
     HEART_RATE("heartRate", HeartRateRecord::class, "bpm"),
     WEIGHT("weight", WeightRecord::class, "kilogram"),
     SLEEP("sleep", SleepSessionRecord::class, "minute"),
-    MOBILITY("mobility", StepsRecord::class, "mixed"); // Using StepsRecord as placeholder
+    MOBILITY("mobility", StepsRecord::class, "mixed"), // Using StepsRecord as placeholder
+    WORKOUT("workout", ExerciseSessionRecord::class, "minute");
 
     val readPermission: String
         get() = HealthPermission.getReadPermission(recordClass)

package/dist/docs.json

@@ -456,6 +456,10 @@
         {
           "text": "'body'",
           "complexTypes": []
+        },
+        {
+          "text": "'workout'",
+          "complexTypes": []
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -1,6 +1,24 @@
-export type HealthDataType = 'steps' | 'distance' | 'calories' | 'heartRate' | 'weight' | 'sleep' | 'mobility' | 'activity' | 'heart' | 'body';
+export type HealthDataType = 'steps' | 'distance' | 'calories' | 'heartRate' | 'weight' | 'sleep' | 'mobility' | 'activity' | 'heart' | 'body' | 'workout';
 export type HealthUnit = 'count' | 'meter' | 'kilocalorie' | 'bpm' | 'kilogram' | 'minute' | 'mixed';
 export type SleepState = 'inBed' | 'asleep' | 'awake' | 'asleepCore' | 'asleepDeep' | 'asleepREM' | 'unknown';
+export interface WorkoutHeartRateZones {
+    zone1?: number;
+    zone2?: number;
+    zone3?: number;
+    zone4?: number;
+    zone5?: number;
+}
+export interface WorkoutData {
+    date: string;
+    type: string;
+    duration: number;
+    distance?: number;
+    calories?: number;
+    source?: string;
+    avgHeartRate?: number;
+    maxHeartRate?: number;
+    zones?: WorkoutHeartRateZones;
+}
 export interface AuthorizationOptions {
     /** Data types that should be readable after authorization. */
     read?: HealthDataType[];

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["  export type HealthDataType = 'steps' | 'distance' | 'calories' | 'heartRate' | 'weight' | 'sleep' | 'mobility' | 'activity' | 'heart' | 'body';\n\nexport type HealthUnit = 'count' | 'meter' | 'kilocalorie' | 'bpm' | 'kilogram' | 'minute' | 'mixed';\nexport type SleepState = 'inBed' | 'asleep' | 'awake' | 'asleepCore' | 'asleepDeep' | 'asleepREM' | 'unknown';\nexport interface AuthorizationOptions {\n  /** Data types that should be readable after authorization. */\n  read?: HealthDataType[];\n  /** Data types that should be writable after authorization. */\n  write?: HealthDataType[];\n}\n\nexport interface AuthorizationStatus {\n  readAuthorized: HealthDataType[];\n  readDenied: HealthDataType[];\n  writeAuthorized: HealthDataType[];\n  writeDenied: HealthDataType[];\n}\n\nexport interface AvailabilityResult {\n  available: boolean;\n  /** Platform specific details (for debugging/diagnostics). */\n  platform?: 'ios' | 'android' | 'web';\n  reason?: string;\n}\n\nexport interface QueryOptions {\n  /** The type of data to retrieve from the health store. */\n  dataType: HealthDataType;\n  /** Inclusive ISO 8601 start date (defaults to now - 1 day). */\n  startDate?: string;\n  /** Exclusive ISO 8601 end date (defaults to now). */\n  endDate?: string;\n  /** Maximum number of samples to return (defaults to 100). */\n  limit?: number;\n  /** Return results sorted ascending by start date (defaults to false). */\n  ascending?: boolean;\n}\n\nexport interface HealthSample {\n  dataType: HealthDataType;\n  value: number;\n  unit: HealthUnit;\n  startDate: string;\n  endDate: string;\n  sourceName?: string;\n  sourceId?: string;\n  /** Sleep state (only present when dataType is 'sleep') */\n  sleepState?: SleepState;\n}\n\nexport interface ReadSamplesResult {\n  samples: HealthSample[];\n}\n\nexport interface WriteSampleOptions {\n  dataType: HealthDataType;\n  value: number;\n  /**\n   * Optional unit override. If omitted, the default unit for the data type is used\n   * (count for `steps`, meter for `distance`, kilocalorie for `calories`, bpm for `heartRate`, kilogram for `weight`, minute for `sleep`).\n   */\n  unit?: HealthUnit;\n  /** ISO 8601 start date for the sample. Defaults to now. */\n  startDate?: string;\n  /** ISO 8601 end date for the sample. Defaults to startDate. */\n  endDate?: string;\n  /** Metadata key-value pairs forwarded to the native APIs where supported. */\n  metadata?: Record<string, string>;\n}\n\nexport interface HealthPlugin {\n  /** Returns whether the current platform supports the native health SDK. */\n  isAvailable(): Promise<AvailabilityResult>;\n  /** Requests read/write access to the provided data types. */\n  requestAuthorization(options: AuthorizationOptions): Promise<AuthorizationStatus>;\n  /** Checks authorization status for the provided data types without prompting the user. */\n  checkAuthorization(options: AuthorizationOptions): Promise<AuthorizationStatus>;\n  /** Reads samples for the given data type within the specified time frame. */\n  readSamples(options: QueryOptions): Promise<ReadSamplesResult>;\n  /** Writes a single sample to the native health store. */\n  saveSample(options: WriteSampleOptions): Promise<void>;\n\n  /**\n   * Get the native Capacitor plugin version\n   *\n   * @returns {Promise<{ id: string }>} an Promise with version for this device\n   * @throws An error if the something went wrong\n   */\n  getPluginVersion(): Promise<{ version: string }>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["  export type HealthDataType = 'steps' | 'distance' | 'calories' | 'heartRate' | 'weight' | 'sleep' | 'mobility' | 'activity' | 'heart' | 'body' | 'workout';\n\nexport type HealthUnit = 'count' | 'meter' | 'kilocalorie' | 'bpm' | 'kilogram' | 'minute' | 'mixed';\nexport type SleepState = 'inBed' | 'asleep' | 'awake' | 'asleepCore' | 'asleepDeep' | 'asleepREM' | 'unknown';\n\nexport interface WorkoutHeartRateZones {\n  zone1?: number; // 50-60% max HR, in minutes\n  zone2?: number; // 60-70% max HR, in minutes\n  zone3?: number; // 70-80% max HR, in minutes\n  zone4?: number; // 80-90% max HR, in minutes\n  zone5?: number; // 90-100% max HR, in minutes\n}\n\nexport interface WorkoutData {\n  date: string; // ISO date (YYYY-MM-DD)\n  type: string; // Activity type (e.g., \"Running\", \"Cycling\")\n  duration: number; // Duration in minutes\n  distance?: number; // Distance in miles\n  calories?: number; // Calories burned\n  source?: string; // Source app name\n  avgHeartRate?: number; // Average heart rate in BPM\n  maxHeartRate?: number; // Maximum heart rate in BPM\n  zones?: WorkoutHeartRateZones; // Heart rate zones\n}\nexport interface AuthorizationOptions {\n  /** Data types that should be readable after authorization. */\n  read?: HealthDataType[];\n  /** Data types that should be writable after authorization. */\n  write?: HealthDataType[];\n}\n\nexport interface AuthorizationStatus {\n  readAuthorized: HealthDataType[];\n  readDenied: HealthDataType[];\n  writeAuthorized: HealthDataType[];\n  writeDenied: HealthDataType[];\n}\n\nexport interface AvailabilityResult {\n  available: boolean;\n  /** Platform specific details (for debugging/diagnostics). */\n  platform?: 'ios' | 'android' | 'web';\n  reason?: string;\n}\n\nexport interface QueryOptions {\n  /** The type of data to retrieve from the health store. */\n  dataType: HealthDataType;\n  /** Inclusive ISO 8601 start date (defaults to now - 1 day). */\n  startDate?: string;\n  /** Exclusive ISO 8601 end date (defaults to now). */\n  endDate?: string;\n  /** Maximum number of samples to return (defaults to 100). */\n  limit?: number;\n  /** Return results sorted ascending by start date (defaults to false). */\n  ascending?: boolean;\n}\n\nexport interface HealthSample {\n  dataType: HealthDataType;\n  value: number;\n  unit: HealthUnit;\n  startDate: string;\n  endDate: string;\n  sourceName?: string;\n  sourceId?: string;\n  /** Sleep state (only present when dataType is 'sleep') */\n  sleepState?: SleepState;\n}\n\nexport interface ReadSamplesResult {\n  samples: HealthSample[];\n}\n\nexport interface WriteSampleOptions {\n  dataType: HealthDataType;\n  value: number;\n  /**\n   * Optional unit override. If omitted, the default unit for the data type is used\n   * (count for `steps`, meter for `distance`, kilocalorie for `calories`, bpm for `heartRate`, kilogram for `weight`, minute for `sleep`).\n   */\n  unit?: HealthUnit;\n  /** ISO 8601 start date for the sample. Defaults to now. */\n  startDate?: string;\n  /** ISO 8601 end date for the sample. Defaults to startDate. */\n  endDate?: string;\n  /** Metadata key-value pairs forwarded to the native APIs where supported. */\n  metadata?: Record<string, string>;\n}\n\nexport interface HealthPlugin {\n  /** Returns whether the current platform supports the native health SDK. */\n  isAvailable(): Promise<AvailabilityResult>;\n  /** Requests read/write access to the provided data types. */\n  requestAuthorization(options: AuthorizationOptions): Promise<AuthorizationStatus>;\n  /** Checks authorization status for the provided data types without prompting the user. */\n  checkAuthorization(options: AuthorizationOptions): Promise<AuthorizationStatus>;\n  /** Reads samples for the given data type within the specified time frame. */\n  readSamples(options: QueryOptions): Promise<ReadSamplesResult>;\n  /** Writes a single sample to the native health store. */\n  saveSample(options: WriteSampleOptions): Promise<void>;\n\n  /**\n   * Get the native Capacitor plugin version\n   *\n   * @returns {Promise<{ id: string }>} an Promise with version for this device\n   * @throws An error if the something went wrong\n   */\n  getPluginVersion(): Promise<{ version: string }>;\n}\n"]}

package/ios/Sources/HealthPlugin/Health.swift

@@ -38,6 +38,7 @@ enum HealthDataType: String, CaseIterable {
     case activity
     case heart
     case body
+    case workout
 
     func sampleType() throws -> HKSampleType {
         if self == .sleep {
@@ -79,6 +80,11 @@ enum HealthDataType: String, CaseIterable {
             return type
         }
         
+        if self == .workout {
+            // Workout uses HKWorkoutType
+            return HKObjectType.workoutType()
+        }
+        
         let identifier: HKQuantityTypeIdentifier
         switch self {
         case .steps:
@@ -101,6 +107,8 @@ enum HealthDataType: String, CaseIterable {
             fatalError("Heart should have been handled above")
         case .body:
             fatalError("Body should have been handled above")
+        case .workout:
+            fatalError("Workout should have been handled above")
         }
 
         guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
@@ -131,6 +139,8 @@ enum HealthDataType: String, CaseIterable {
             return HKUnit.count().unitDivided(by: HKUnit.minute()) // Placeholder, heart has multiple units
         case .body:
             return HKUnit.gramUnit(with: .kilo) // Placeholder, body has multiple units
+        case .workout:
+            return HKUnit.minute() // Workout duration in minutes
         }
     }
 
@@ -156,6 +166,8 @@ enum HealthDataType: String, CaseIterable {
             return "mixed" // Heart has multiple units
         case .body:
             return "mixed" // Body has multiple units
+        case .workout:
+            return "minute" // Workout duration in minutes
         }
     }
 
@@ -324,6 +336,19 @@ final class Health {
             return
         }
         
+        // Handle workout data
+        if dataType == .workout {
+            processWorkoutData(startDate: startDate, endDate: endDate, limit: limit, ascending: ascending) { result in
+                switch result {
+                case .success(let workoutData):
+                    completion(.success(workoutData))
+                case .failure(let error):
+                    completion(.failure(error))
+                }
+            }
+            return
+        }
+        
         // For all other data types, use the standard query approach
         let sampleType = try dataType.sampleType()
         let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: [])
@@ -1341,6 +1366,12 @@ final class Health {
     private func processMobilityData(startDate: Date, endDate: Date, completion: @escaping (Result<[[String: Any]], Error>) -> Void) {
         let calendar = Calendar.current
         
+        // Calculate the local date range that corresponds to the input UTC date range
+        let startDateComponents = calendar.dateComponents([.year, .month, .day], from: startDate)
+        let endDateComponents = calendar.dateComponents([.year, .month, .day], from: endDate)
+        let localStartDateString = String(format: "%04d-%02d-%02d", startDateComponents.year!, startDateComponents.month!, startDateComponents.day!)
+        let localEndDateString = String(format: "%04d-%02d-%02d", endDateComponents.year!, endDateComponents.month!, endDateComponents.day!)
+        
         // Define all mobility quantity types
         let mobilityTypes: [(HKQuantityTypeIdentifier, String)] = [
             (.walkingSpeed, "walkingSpeed"),
@@ -1480,10 +1511,15 @@ final class Health {
             allDates.formUnion(stairSpeedMap.keys)
             allDates.formUnion(sixMinWalkMap.keys)
             
+            // Filter dates to only include those within the requested local date range
+            let filteredDates = allDates.filter { date in
+                return date >= localStartDateString && date <= localEndDateString
+            }
+            
             // Create mobility data array with aggregated daily averages
             var mobilityData: [[String: Any]] = []
             
-            for date in allDates.sorted() {
+            for date in filteredDates.sorted() {
                 var result: [String: Any] = ["date": date]
                 
                 // Average all measurements for the day
@@ -1531,6 +1567,13 @@ final class Health {
         let group = DispatchGroup()
         let lock = NSLock()
         
+        // Calculate the local date range that corresponds to the input UTC date range
+        // This ensures we only return data for dates that fall within the requested range
+        let startDateComponents = calendar.dateComponents([.year, .month, .day], from: startDate)
+        let endDateComponents = calendar.dateComponents([.year, .month, .day], from: endDate)
+        let localStartDateString = String(format: "%04d-%02d-%02d", startDateComponents.year!, startDateComponents.month!, startDateComponents.day!)
+        let localEndDateString = String(format: "%04d-%02d-%02d", endDateComponents.year!, endDateComponents.month!, endDateComponents.day!)
+        
         // Maps to store values by date for each metric
         var stepsMap: [String: Double] = [:]
         var distanceMap: [String: Double] = [:]
@@ -1744,8 +1787,14 @@ final class Health {
             allDates.formUnion(exerciseMinutesMap.keys)
             allDates.formUnion(standHoursMap.keys)
             
+            // Filter dates to only include those within the requested local date range
+            // This prevents returning data from dates outside the user's intended range
+            let filteredDates = allDates.filter { date in
+                return date >= localStartDateString && date <= localEndDateString
+            }
+            
             // Create activity data array matching the reference format
-            let activityData: [[String: Any]] = allDates.sorted().compactMap { date in
+            let activityData: [[String: Any]] = filteredDates.sorted().compactMap { date in
                 var result: [String: Any] = ["date": date]
                 
                 // Add each metric if available, with proper rounding
@@ -1787,6 +1836,12 @@ final class Health {
         let group = DispatchGroup()
         let lock = NSLock()
         
+        // Calculate the local date range that corresponds to the input UTC date range
+        let startDateComponents = calendar.dateComponents([.year, .month, .day], from: startDate)
+        let endDateComponents = calendar.dateComponents([.year, .month, .day], from: endDate)
+        let localStartDateString = String(format: "%04d-%02d-%02d", startDateComponents.year!, startDateComponents.month!, startDateComponents.day!)
+        let localEndDateString = String(format: "%04d-%02d-%02d", endDateComponents.year!, endDateComponents.month!, endDateComponents.day!)
+        
         // Maps to store values by date for each metric
         struct HeartRateStats {
             var sum: Double = 0
@@ -2015,8 +2070,13 @@ final class Health {
             allDates.formUnion(spo2Map.keys)
             allDates.formUnion(respirationRateMap.keys)
             
+            // Filter dates to only include those within the requested local date range
+            let filteredDates = allDates.filter { date in
+                return date >= localStartDateString && date <= localEndDateString
+            }
+            
             // Create heart data array matching the TypeScript format
-            let heartData: [[String: Any]] = allDates.sorted().compactMap { date in
+            let heartData: [[String: Any]] = filteredDates.sorted().compactMap { date in
                 var result: [String: Any] = ["date": date]
                 
                 // Heart Rate (avg, min, max, count)
@@ -2060,4 +2120,302 @@ final class Health {
             completion(.success(heartData))
         }
     }
+    
+    // MARK: - Workout Data Processing
+    
+    private func processWorkoutData(startDate: Date, endDate: Date, limit: Int?, ascending: Bool, completion: @escaping (Result<[[String: Any]], Error>) -> Void) {
+        let workoutType = HKObjectType.workoutType()
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: [])
+        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: ascending)
+        let queryLimit = limit ?? HKObjectQueryNoLimit
+        
+        let query = HKSampleQuery(sampleType: workoutType, predicate: predicate, limit: queryLimit, sortDescriptors: [sortDescriptor]) { [weak self] _, samples, error in
+            guard let self = self else { return }
+            
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let workouts = samples as? [HKWorkout], !workouts.isEmpty else {
+                completion(.success([]))
+                return
+            }
+            
+            var workoutData: [[String: Any]] = []
+            let group = DispatchGroup()
+            let lock = NSLock()
+            
+            for workout in workouts {
+                group.enter()
+                
+                // Extract basic workout info
+                let dateFormatter = ISO8601DateFormatter()
+                dateFormatter.formatOptions = [.withFullDate]
+                let date = dateFormatter.string(from: workout.startDate)
+                
+                // Get workout type (remove "HKWorkoutActivityType" prefix to match XML format)
+                let activityTypeString = self.workoutActivityTypeString(for: workout.workoutActivityType)
+                
+                // Duration in minutes (matching XML parser logic)
+                let durationInMinutes = Int(round(workout.duration / 60.0))
+                
+                // Distance in miles (if available)
+                var distance: Double?
+                if let totalDistance = workout.totalDistance {
+                    let distanceInMeters = totalDistance.doubleValue(for: HKUnit.meter())
+                    distance = distanceInMeters * 0.000621371 // meters to miles
+                }
+                
+                // Calories (if available)
+                var calories: Int?
+                if let totalEnergy = workout.totalEnergyBurned {
+                    let caloriesValue = totalEnergy.doubleValue(for: HKUnit.kilocalorie())
+                    calories = Int(round(caloriesValue))
+                }
+                
+                // Source name
+                let source = workout.sourceRevision.source.name
+                
+                // Query for heart rate statistics during this workout
+                self.queryWorkoutHeartRateStatistics(for: workout) { avgHR, maxHR in
+                    // Query for heart rate zones
+                    self.queryWorkoutHeartRateZones(for: workout) { zones in
+                        lock.lock()
+                        
+                        var workoutDict: [String: Any] = [
+                            "date": date,
+                            "type": activityTypeString,
+                            "duration": durationInMinutes,
+                            "source": source
+                        ]
+                        
+                        if let distance = distance {
+                            workoutDict["distance"] = round(distance * 100) / 100 // 2 decimal places
+                        }
+                        
+                        if let calories = calories {
+                            workoutDict["calories"] = calories
+                        }
+                        
+                        if let avgHR = avgHR {
+                            workoutDict["avgHeartRate"] = avgHR
+                        }
+                        
+                        if let maxHR = maxHR {
+                            workoutDict["maxHeartRate"] = maxHR
+                        }
+                        
+                        if !zones.isEmpty {
+                            workoutDict["zones"] = zones
+                        }
+                        
+                        workoutData.append(workoutDict)
+                        lock.unlock()
+                        
+                        group.leave()
+                    }
+                }
+            }
+            
+            group.notify(queue: .main) {
+                // Sort by date if needed
+                let sortedData = workoutData.sorted { dict1, dict2 in
+                    guard let date1 = dict1["date"] as? String,
+                          let date2 = dict2["date"] as? String else {
+                        return false
+                    }
+                    return ascending ? date1 < date2 : date1 > date2
+                }
+                
+                completion(.success(sortedData))
+            }
+        }
+        
+        healthStore.execute(query)
+    }
+    
+    private func workoutActivityTypeString(for type: HKWorkoutActivityType) -> String {
+        // Return the activity type name without the "HKWorkoutActivityType" prefix
+        // to match the XML export format
+        switch type {
+        case .running: return "Running"
+        case .cycling: return "Cycling"
+        case .walking: return "Walking"
+        case .swimming: return "Swimming"
+        case .yoga: return "Yoga"
+        case .functionalStrengthTraining: return "FunctionalStrengthTraining"
+        case .traditionalStrengthTraining: return "TraditionalStrengthTraining"
+        case .elliptical: return "Elliptical"
+        case .rowing: return "Rowing"
+        case .hiking: return "Hiking"
+        case .highIntensityIntervalTraining: return "HighIntensityIntervalTraining"
+        case .dance: return "Dance"
+        case .basketball: return "Basketball"
+        case .soccer: return "Soccer"
+        case .tennis: return "Tennis"
+        case .golf: return "Golf"
+        case .stairClimbing: return "StairClimbing"
+        case .stepTraining: return "StepTraining"
+        case .kickboxing: return "Kickboxing"
+        case .pilates: return "Pilates"
+        case .boxing: return "Boxing"
+        case .taiChi: return "TaiChi"
+        case .crossTraining: return "CrossTraining"
+        case .mindAndBody: return "MindAndBody"
+        case .coreTraining: return "CoreTraining"
+        case .flexibility: return "Flexibility"
+        case .cooldown: return "Cooldown"
+        case .wheelchairWalkPace: return "WheelchairWalkPace"
+        case .wheelchairRunPace: return "WheelchairRunPace"
+        case .other: return "Other"
+        default:
+            // For any unknown or new types
+            return "Other"
+        }
+    }
+    
+    private func queryWorkoutHeartRateStatistics(for workout: HKWorkout, completion: @escaping (Int?, Int?) -> Void) {
+        guard let heartRateType = HKObjectType.quantityType(forIdentifier: .heartRate) else {
+            completion(nil, nil)
+            return
+        }
+        
+        let predicate = HKQuery.predicateForSamples(withStart: workout.startDate, end: workout.endDate, options: .strictStartDate)
+        
+        let query = HKStatisticsQuery(quantityType: heartRateType, quantitySamplePredicate: predicate, options: [.discreteAverage, .discreteMax]) { _, statistics, error in
+            if error != nil {
+                completion(nil, nil)
+                return
+            }
+            
+            var avgHR: Int?
+            var maxHR: Int?
+            
+            if let avgQuantity = statistics?.averageQuantity() {
+                let bpm = avgQuantity.doubleValue(for: HKUnit.count().unitDivided(by: HKUnit.minute()))
+                avgHR = Int(round(bpm))
+            }
+            
+            if let maxQuantity = statistics?.maximumQuantity() {
+                let bpm = maxQuantity.doubleValue(for: HKUnit.count().unitDivided(by: HKUnit.minute()))
+                maxHR = Int(round(bpm))
+            }
+            
+            completion(avgHR, maxHR)
+        }
+        
+        healthStore.execute(query)
+    }
+    
+    private func queryWorkoutHeartRateZones(for workout: HKWorkout, completion: @escaping ([String: Int]) -> Void) {
+        // Check if heart rate zone data is available in workout metadata
+        var zones: [String: Int] = [:]
+        
+        if let metadata = workout.metadata {
+            // Look for heart rate zone keys in metadata
+            // Apple Health stores zones as HKMetadataKeyHeartRateEventThreshold or custom keys
+            for (key, value) in metadata {
+                if key.contains("Zone") || key.contains("zone") {
+                    // Try to extract zone number
+                    if let zoneMatch = key.range(of: #"\d+"#, options: .regularExpression),
+                       let zoneNum = Int(key[zoneMatch]) {
+                        // Value might be in seconds, convert to minutes
+                        if let seconds = value as? Double {
+                            let minutes = Int(round(seconds / 60.0))
+                            zones["zone\(zoneNum)"] = minutes
+                        } else if let minutes = value as? Int {
+                            zones["zone\(zoneNum)"] = minutes
+                        }
+                    }
+                }
+            }
+        }
+        
+        // If no zones found in metadata, try querying heart rate samples to calculate zones
+        if zones.isEmpty {
+            calculateHeartRateZones(for: workout) { calculatedZones in
+                completion(calculatedZones)
+            }
+        } else {
+            completion(zones)
+        }
+    }
+    
+    private func calculateHeartRateZones(for workout: HKWorkout, completion: @escaping ([String: Int]) -> Void) {
+        guard let heartRateType = HKObjectType.quantityType(forIdentifier: .heartRate) else {
+            completion([:])
+            return
+        }
+        
+        let predicate = HKQuery.predicateForSamples(withStart: workout.startDate, end: workout.endDate, options: .strictStartDate)
+        let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: true)
+        
+        let query = HKSampleQuery(sampleType: heartRateType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: [sortDescriptor]) { _, samples, error in
+            if error != nil || samples == nil {
+                completion([:])
+                return
+            }
+            
+            guard let heartRateSamples = samples as? [HKQuantitySample], !heartRateSamples.isEmpty else {
+                completion([:])
+                return
+            }
+            
+            // Calculate zones based on standard heart rate zone definitions
+            // Zone 1: 50-60% max HR
+            // Zone 2: 60-70% max HR
+            // Zone 3: 70-80% max HR
+            // Zone 4: 80-90% max HR
+            // Zone 5: 90-100% max HR
+            
+            // Estimate max HR (220 - age), or use 180 as a reasonable default
+            let estimatedMaxHR = 180.0
+            
+            var zoneMinutes: [Int: TimeInterval] = [1: 0, 2: 0, 3: 0, 4: 0, 5: 0]
+            
+            for i in 0..<heartRateSamples.count {
+                let sample = heartRateSamples[i]
+                let bpm = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: HKUnit.minute()))
+                let percentMax = (bpm / estimatedMaxHR) * 100
+                
+                // Determine zone
+                let zone: Int
+                if percentMax < 60 {
+                    zone = 1
+                } else if percentMax < 70 {
+                    zone = 2
+                } else if percentMax < 80 {
+                    zone = 3
+                } else if percentMax < 90 {
+                    zone = 4
+                } else {
+                    zone = 5
+                }
+                
+                // Calculate time in this zone (use interval to next sample or default to 5 seconds)
+                let duration: TimeInterval
+                if i < heartRateSamples.count - 1 {
+                    duration = heartRateSamples[i + 1].startDate.timeIntervalSince(sample.startDate)
+                } else {
+                    duration = 5.0 // Default 5 seconds for last sample
+                }
+                
+                zoneMinutes[zone, default: 0] += duration
+            }
+            
+            // Convert seconds to minutes and filter out zones with 0 minutes
+            var zones: [String: Int] = [:]
+            for (zone, seconds) in zoneMinutes {
+                let minutes = Int(round(seconds / 60.0))
+                if minutes > 0 {
+                    zones["zone\(zone)"] = minutes
+                }
+            }
+            
+            completion(zones)
+        }
+        
+        healthStore.execute(query)
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interval-health/capacitor-health",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "Capacitor plugin to interact with data from Apple HealthKit and Health Connect",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",