@tryterra/react-native 2.1.0 → 2.2.1

package/ios/TerraBridgeCore/Conversions+Reads.swift

@@ -0,0 +1,259 @@
+import Foundation
+import TerraSDK
+
+extension Conversions {
+
+    static func dayTotalMetric(_ metric: TerraSDK.DayTotal.Metric) -> DayTotalMetric? {
+        switch metric {
+        case .distanceWalkingRunning: return .distanceWalkingRunning
+        case .distanceCycling: return .distanceCycling
+        case .distanceSwimming: return .distanceSwimming
+        case .distanceWheelchair: return .distanceWheelchair
+        case .activeEnergyBurned: return .activeEnergyBurned
+        case .basalEnergyBurned: return .basalEnergyBurned
+        case .flightsClimbed: return .flightsClimbed
+        case .appleExerciseTime: return .appleExerciseTime
+        case .steps, .swimmingStrokeCount, .appleMoveTime, .appleStandTime, .appleStandHours: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func dayTotal(_ total: TerraSDK.DayTotal) -> DayTotal? {
+        dayTotalMetric(total.metric).map {
+            DayTotal(
+                metric: $0,
+                start: BridgeInstant.format(total.interval.start),
+                end: BridgeInstant.format(total.interval.end),
+                value: total.value,
+                unit: total.unit,
+                timeZone: total.timeZone?.identifier)
+        }
+    }
+
+    static func intradayMetric(_ kind: TerraSDK.IntradaySample.Kind) -> IntradayMetric? {
+        switch kind {
+        case .activeEnergy: return .activeEnergy
+        case .basalEnergy: return .basalEnergy
+        case .distance: return .distance
+        case .floorsClimbed: return .floorsClimbed
+        @unknown default: return nil
+        }
+    }
+
+    static func intraday(_ sample: TerraSDK.IntradaySample) -> IntradaySample? {
+        intradayMetric(sample.kind).map {
+            IntradaySample(
+                id: sample.id.uuidString,
+                metric: $0,
+                start: BridgeInstant.format(sample.interval.start),
+                end: BridgeInstant.format(sample.interval.end),
+                value: sample.value,
+                source: sampleSource(sample.source),
+                userEntered: sample.userEntered,
+                timeZone: sample.timeZone?.identifier)
+        }
+    }
+
+    static func restingHeartRate(_ sample: TerraSDK.RestingHeartRateSample) -> RestingHeartRateSample {
+        RestingHeartRateSample(
+            id: sample.id.uuidString,
+            start: BridgeInstant.format(sample.interval.start),
+            end: BridgeInstant.format(sample.interval.end),
+            beatsPerMinute: sample.beatsPerMinute,
+            source: sampleSource(sample.source),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func bodyMetric(_ metric: TerraSDK.BodyMetric) -> BodyMetric? {
+        switch metric {
+        case .weight: return .weight
+        case .height: return .height
+        case .bodyFatPercentage: return .bodyFatPercentage
+        case .leanBodyMass: return .leanBodyMass
+        case .bmi: return .bmi
+        case .waistCircumference: return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func glucoseUnit(_ unit: TerraSDK.BloodGlucoseUnit) -> BloodGlucoseUnit {
+        switch unit {
+        case .milligramsPerDecilitre: return .milligramsPerDecilitre
+        case .millimolesPerLitre: return .millimolesPerLitre
+        @unknown default: return .milligramsPerDecilitre
+        }
+    }
+
+    static func mealTime(_ time: TerraSDK.GlucoseMealTime) -> GlucoseMealTime {
+        switch time {
+        case .preprandial: return .preprandial
+        case .postprandial: return .postprandial
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func specimen(_ specimen: TerraSDK.GlucoseSpecimen) -> GlucoseSpecimen {
+        switch specimen {
+        case .capillary: return .capillary
+        case .interstitial: return .interstitial
+        case .plasma: return .plasma
+        case .serum: return .serum
+        case .tears: return .tears
+        case .wholeBlood: return .wholeBlood
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func temperatureMetric(_ metric: TerraSDK.BodyTemperatureMetric) -> BodyTemperatureMetric? {
+        switch metric {
+        case .body: return .body
+        case .basal: return .basal
+        case .wrist: return .wrist
+        case .skin: return .skin
+        @unknown default: return nil
+        }
+    }
+
+    static func variabilityMetric(_ metric: TerraSDK.HeartRateVariabilityMetric) -> HeartRateVariabilityMetric? {
+        switch metric {
+        case .sdnn: return .sdnn
+        case .rmssd: return .rmssd
+        @unknown default: return nil
+        }
+    }
+
+    static func testType(_ type: TerraSDK.VO2MaxTestType) -> VO2MaxTestType? {
+        switch type {
+        case .maxExercise: return .maxExercise
+        case .predictedSubMaxExercise: return .predictedSubMaxExercise
+        case .predictedNonExercise: return .predictedNonExercise
+        @unknown default: return nil
+        }
+    }
+
+    static func bodyReadingKind(_ kind: TerraSDK.BodyReading.Kind) -> BodyReadingKind? {
+        switch kind {
+        case .measurement(let metric, let value):
+            return bodyMetric(metric).map { .measurement(metric: $0, value: value) }
+        case .bloodPressure(let systolic, let diastolic):
+            return .bloodPressure(systolic: systolic, diastolic: diastolic)
+        case .bloodGlucose(let value, let unit, let mealTime, let specimen):
+            return .bloodGlucose(
+                value: value, unit: glucoseUnit(unit), mealTime: mealTime.map(Self.mealTime),
+                specimen: specimen.map(Self.specimen))
+        case .oxygenSaturation(let fraction):
+            return .oxygenSaturation(fraction: fraction)
+        case .temperature(let metric, let celsius):
+            return temperatureMetric(metric).map { .temperature(metric: $0, celsius: celsius) }
+        case .heartRateVariability(let metric, let milliseconds):
+            return variabilityMetric(metric).map { .heartRateVariability(metric: $0, milliseconds: milliseconds) }
+        case .respiratoryRate(let breathsPerMinute):
+            return .respiratoryRate(breathsPerMinute: breathsPerMinute)
+        case .vo2Max(let value, let type):
+            return .vo2Max(millilitresPerKilogramMinute: value, testType: type.flatMap(testType))
+        case .insulinDelivery, .electrocardiogram, .heartbeatSeries:
+            return nil
+        @unknown default:
+            return nil
+        }
+    }
+
+    static func bodyReading(_ reading: TerraSDK.BodyReading) -> BodyReading? {
+        bodyReadingKind(reading.kind).map {
+            BodyReading(
+                id: reading.id.uuidString,
+                kind: $0,
+                start: BridgeInstant.format(reading.interval.start),
+                end: BridgeInstant.format(reading.interval.end),
+                source: sampleSource(reading.source),
+                userEntered: reading.userEntered,
+                timeZone: reading.timeZone?.identifier)
+        }
+    }
+
+    static func route(_ route: TerraSDK.WorkoutRoute) -> WorkoutRoute {
+        WorkoutRoute(
+            id: route.id.uuidString,
+            workoutId: route.workoutId.uuidString,
+            start: BridgeInstant.format(route.interval.start),
+            end: BridgeInstant.format(route.interval.end),
+            points: route.points.map {
+                RoutePoint(time: BridgeInstant.format($0.time), latitude: $0.latitude, longitude: $0.longitude)
+            },
+            source: sampleSource(route.source),
+            timeZone: route.timeZone?.identifier)
+    }
+
+    static func intensityMetric(_ kind: TerraSDK.WorkoutIntensitySample.Kind) -> WorkoutIntensityMetric? {
+        switch kind {
+        case .speed: return .speed
+        case .power: return .power
+        case .cadence: return .cadence
+        @unknown default: return nil
+        }
+    }
+
+    static func intensity(_ sample: TerraSDK.WorkoutIntensitySample) -> WorkoutIntensitySample? {
+        intensityMetric(sample.kind).map {
+            WorkoutIntensitySample(
+                id: sample.id.uuidString,
+                metric: $0,
+                workoutId: sample.workoutId.uuidString,
+                start: BridgeInstant.format(sample.interval.start),
+                end: BridgeInstant.format(sample.interval.end),
+                value: sample.value,
+                source: sampleSource(sample.source),
+                userEntered: sample.userEntered,
+                timeZone: sample.timeZone?.identifier)
+        }
+    }
+
+    static func hydration(_ sample: TerraSDK.HydrationSample) -> HydrationSample {
+        HydrationSample(
+            id: sample.id.uuidString,
+            start: BridgeInstant.format(sample.interval.start),
+            end: BridgeInstant.format(sample.interval.end),
+            millilitres: sample.millilitres,
+            source: sampleSource(sample.source),
+            userEntered: sample.userEntered,
+            timeZone: sample.timeZone?.identifier)
+    }
+
+    static func availability(_ availability: TerraSDK.StoreAvailability) -> StoreAvailability {
+        switch availability {
+        case .available: return .available
+        case .unsupportedDevice: return .unsupportedDevice
+        @unknown default: return .unsupportedDevice
+        }
+    }
+
+    static func eventKind(_ kind: TerraSDK.MenstrualEvent.Kind) -> MenstrualEventKind? {
+        switch kind {
+        case .intermenstrualBleeding: return .intermenstrualBleeding
+        case .ovulationTest: return .ovulationTest
+        case .cervicalMucus: return .cervicalMucus
+        case .sexualActivity, .pregnancyTest, .progesteroneTest, .pregnancy, .lactation, .contraceptive,
+             .persistentIntermenstrualBleeding, .infrequentCycles, .irregularCycles, .prolongedPeriods,
+             .bleedingDuringPregnancy, .bleedingAfterPregnancy:
+            return nil
+        @unknown default: return nil
+        }
+    }
+
+    static func menstrualEvent(_ event: TerraSDK.MenstrualEvent) -> MenstrualEvent? {
+        eventKind(event.kind).map {
+            MenstrualEvent(
+                id: event.id.uuidString,
+                kind: $0,
+                time: BridgeInstant.format(event.instant),
+                value: event.value,
+                storeIdentifier: event.storeIdentifier,
+                source: sampleSource(event.source),
+                userEntered: event.userEntered,
+                timeZone: event.timeZone?.identifier)
+        }
+    }
+}

package/ios/TerraBridgeCore/Conversions.swift

@@ -77,6 +77,8 @@ enum Conversions {
         case .daily: return .daily
         case .sleep: return .sleep
         case .nutrition: return .nutrition
+        case .menstruation: return .menstruation
+        case .athlete: return .athlete
         }
     }
 
@@ -88,7 +90,9 @@ enum Conversions {
         case .daily: return .daily
         case .sleep: return .sleep
         case .nutrition: return .nutrition
-        case .menstruation, .athlete, .healthObservation: return nil
+        case .menstruation: return .menstruation
+        case .athlete: return .athlete
+        case .healthObservation: return nil
         @unknown default: return nil
         }
     }
@@ -270,7 +274,130 @@ enum Conversions {
             distanceMeters: workout.distanceMeters,
             source: sampleSource(workout.source),
             userEntered: workout.userEntered,
-            timeZone: workout.timeZone?.identifier)
+            timeZone: workout.timeZone?.identifier,
+            title: workout.title)
+    }
+
+    static func nutrient(_ nutrient: TerraSDK.Nutrient) -> Nutrient? {
+        switch nutrient {
+        case .energyConsumed: return .energyConsumed
+        case .protein: return .protein
+        case .carbohydrates: return .carbohydrates
+        case .fatTotal: return .fatTotal
+        case .fatSaturated: return .fatSaturated
+        case .fatMonounsaturated: return .fatMonounsaturated
+        case .fatPolyunsaturated: return .fatPolyunsaturated
+        case .sugar: return .sugar
+        case .fiber: return .fiber
+        case .cholesterol: return .cholesterol
+        case .sodium: return .sodium
+        case .potassium: return .potassium
+        case .calcium: return .calcium
+        case .iron: return .iron
+        case .magnesium: return .magnesium
+        case .zinc: return .zinc
+        case .phosphorus: return .phosphorus
+        case .iodine: return .iodine
+        case .manganese: return .manganese
+        case .molybdenum: return .molybdenum
+        case .selenium: return .selenium
+        case .copper: return .copper
+        case .chromium: return .chromium
+        case .chloride: return .chloride
+        case .caffeine: return .caffeine
+        case .vitaminA: return .vitaminA
+        case .vitaminC: return .vitaminC
+        case .vitaminD: return .vitaminD
+        case .vitaminE: return .vitaminE
+        case .vitaminK: return .vitaminK
+        case .vitaminB6: return .vitaminB6
+        case .vitaminB12: return .vitaminB12
+        case .thiamin: return .thiamin
+        case .riboflavin: return .riboflavin
+        case .niacin: return .niacin
+        case .folate: return .folate
+        case .biotin: return .biotin
+        case .pantothenicAcid: return .pantothenicAcid
+        @unknown default: return nil
+        }
+    }
+
+    static func mealType(_ type: TerraSDK.MealType) -> MealType {
+        switch type {
+        case .breakfast: return .breakfast
+        case .lunch: return .lunch
+        case .dinner: return .dinner
+        case .snack: return .snack
+        case .unknown: return .unknown
+        @unknown default: return .unknown
+        }
+    }
+
+    static func flow(_ flow: TerraSDK.MenstruationFlowDay.Flow) -> MenstruationFlow {
+        switch flow {
+        case .unspecified: return .unspecified
+        case .light: return .light
+        case .medium: return .medium
+        case .heavy: return .heavy
+        case .noFlow: return .noFlow
+        @unknown default: return .unspecified
+        }
+    }
+
+    static func biologicalSex(_ sex: TerraSDK.AthleteProfile.BiologicalSex) -> BiologicalSex {
+        switch sex {
+        case .female: return .female
+        case .male: return .male
+        case .other: return .other
+        case .notSet: return .notSet
+        @unknown default: return .notSet
+        }
+    }
+
+    static func moveMode(_ mode: TerraSDK.AthleteProfile.ActivityMoveMode) -> ActivityMoveMode? {
+        switch mode {
+        case .activeEnergy: return .activeEnergy
+        case .appleMoveTime: return .appleMoveTime
+        @unknown default: return nil
+        }
+    }
+
+    static func quantity(_ quantity: TerraSDK.DietaryQuantity) -> DietaryQuantity? {
+        guard let nutrient = nutrient(quantity.nutrient) else { return nil }
+        return DietaryQuantity(
+            id: quantity.id.uuidString,
+            nutrient: nutrient,
+            value: quantity.value,
+            start: BridgeInstant.format(quantity.interval.start),
+            end: BridgeInstant.format(quantity.interval.end),
+            mealType: mealType(quantity.mealType),
+            name: quantity.name,
+            foodCorrelationId: quantity.foodCorrelationID?.uuidString,
+            source: sampleSource(quantity.source),
+            userEntered: quantity.userEntered,
+            timeZone: quantity.timeZone?.identifier)
+    }
+
+    static func flowDay(_ day: TerraSDK.MenstruationFlowDay) -> MenstruationFlowDay {
+        MenstruationFlowDay(
+            id: day.id.uuidString,
+            start: BridgeInstant.format(day.interval.start),
+            end: BridgeInstant.format(day.interval.end),
+            flow: flow(day.flow),
+            cycleStart: day.cycleStart,
+            source: sampleSource(day.source),
+            userEntered: day.userEntered,
+            timeZone: day.timeZone?.identifier)
+    }
+
+    /// The birth date is a calendar day. HealthKit hands back components, which the store turns into
+    /// a `Date` at midnight in the device's zone, so the same zone reads the same day back out.
+    static func athleteProfile(_ profile: TerraSDK.AthleteProfile, zone: TimeZone) -> AthleteProfile {
+        AthleteProfile(
+            biologicalSex: biologicalSex(profile.biologicalSex),
+            dateOfBirth: profile.dateOfBirth.map { localDate($0, in: zone) },
+            wheelchairUse: profile.wheelchairUse,
+            activityMoveMode: profile.activityMoveMode.flatMap(moveMode))
     }
 
     /// A day, not an instant: sending the instant would let the receiver re-derive the day in its