react-native-workouts 0.1.0

package/ios/ReactNativeWorkoutsModule.swift

@@ -0,0 +1,657 @@
+import ExpoModulesCore
+import WorkoutKit
+import HealthKit
+
+public class ReactNativeWorkoutsModule: Module {
+    private let healthStore = HKHealthStore()
+
+    public func definition() -> ModuleDefinition {
+        Name("ReactNativeWorkouts")
+
+        // MARK: - Constants
+
+        Constants([
+            "isAvailable": HKHealthStore.isHealthDataAvailable()
+        ])
+
+        // MARK: - Events
+
+        Events("onAuthorizationChange")
+
+        // MARK: - Authorization
+
+        AsyncFunction("getAuthorizationStatus") { () -> String in
+            let status = await WorkoutScheduler.shared.authorizationState
+            return self.authorizationStateToString(status)
+        }
+
+        AsyncFunction("requestAuthorization") { () -> String in
+            let status = await WorkoutScheduler.shared.requestAuthorization()
+            return self.authorizationStateToString(status)
+        }
+
+        // MARK: - Workout Validation
+
+        AsyncFunction("supportsGoal") { (activityType: String, locationType: String, goalType: String) -> Bool in
+            guard let activity = self.parseActivityType(activityType),
+                  let location = self.parseLocationType(locationType),
+                  let goal = self.parseGoalTypeForValidation(goalType) else {
+                return false
+            }
+
+            return CustomWorkout.supports(goal: goal, activity: activity, location: location)
+        }
+
+        // MARK: - Custom Workout Creation
+
+        AsyncFunction("createCustomWorkout") { (config: [String: Any]) throws -> [String: Any] in
+            let workout = try self.buildCustomWorkout(from: config)
+            let composition = CustomWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+                return [
+                    "valid": true,
+                    "displayName": workout.displayName ?? ""
+                ]
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+        }
+
+        // MARK: - Scheduled Workouts
+
+        AsyncFunction("scheduleWorkout") { (config: [String: Any], date: [String: Any]) throws -> [String: Any] in
+            let workout = try self.buildCustomWorkout(from: config)
+            let composition = CustomWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+
+            let dateComponents = self.parseDateComponents(from: date)
+            let plan = ScheduledWorkoutPlan(workout: composition, date: dateComponents)
+
+            do {
+                try await WorkoutScheduler.shared.schedule(plan)
+                return [
+                    "success": true,
+                    "id": plan.id.uuidString
+                ]
+            } catch {
+                throw Exception(name: "ScheduleError", description: error.localizedDescription)
+            }
+        }
+
+        AsyncFunction("getScheduledWorkouts") { () throws -> [[String: Any]] in
+            let workouts = await WorkoutScheduler.shared.scheduledWorkouts
+            return workouts.map { plan in
+                return [
+                    "id": plan.id.uuidString,
+                    "date": self.dateComponentsToDict(plan.date)
+                ]
+            }
+        }
+
+        AsyncFunction("removeScheduledWorkout") { (id: String) throws -> Bool in
+            guard let uuid = UUID(uuidString: id) else {
+                throw Exception(name: "InvalidID", description: "Invalid workout ID format")
+            }
+
+            let workouts = await WorkoutScheduler.shared.scheduledWorkouts
+            guard let workout = workouts.first(where: { $0.id == uuid }) else {
+                throw Exception(name: "NotFound", description: "Workout not found")
+            }
+
+            do {
+                try await WorkoutScheduler.shared.remove(workout)
+                return true
+            } catch {
+                throw Exception(name: "RemoveError", description: error.localizedDescription)
+            }
+        }
+
+        AsyncFunction("removeAllScheduledWorkouts") { () throws -> Bool in
+            let workouts = await WorkoutScheduler.shared.scheduledWorkouts
+
+            for workout in workouts {
+                do {
+                    try await WorkoutScheduler.shared.remove(workout)
+                } catch {
+                    throw Exception(name: "RemoveError", description: error.localizedDescription)
+                }
+            }
+
+            return true
+        }
+
+        // MARK: - Single Goal Workout
+
+        AsyncFunction("createSingleGoalWorkout") { (config: [String: Any]) throws -> [String: Any] in
+            guard let activityTypeStr = config["activityType"] as? String,
+                  let activity = self.parseActivityType(activityTypeStr),
+                  let goalConfig = config["goal"] as? [String: Any] else {
+                throw Exception(name: "InvalidConfig", description: "Missing required fields: activityType, goal")
+            }
+
+            let goal = try self.parseWorkoutGoal(from: goalConfig)
+            let location = self.parseLocationType(config["locationType"] as? String ?? "outdoor") ?? .outdoor
+            let displayName = config["displayName"] as? String
+
+            let workout = SingleGoalWorkout(activity: activity, location: location, goal: goal, displayName: displayName)
+            let composition = SingleGoalWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+                return [
+                    "valid": true,
+                    "displayName": workout.displayName ?? ""
+                ]
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+        }
+
+        AsyncFunction("scheduleSingleGoalWorkout") { (config: [String: Any], date: [String: Any]) throws -> [String: Any] in
+            guard let activityTypeStr = config["activityType"] as? String,
+                  let activity = self.parseActivityType(activityTypeStr),
+                  let goalConfig = config["goal"] as? [String: Any] else {
+                throw Exception(name: "InvalidConfig", description: "Missing required fields: activityType, goal")
+            }
+
+            let goal = try self.parseWorkoutGoal(from: goalConfig)
+            let location = self.parseLocationType(config["locationType"] as? String ?? "outdoor") ?? .outdoor
+            let displayName = config["displayName"] as? String
+
+            let workout = SingleGoalWorkout(activity: activity, location: location, goal: goal, displayName: displayName)
+            let composition = SingleGoalWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+
+            let dateComponents = self.parseDateComponents(from: date)
+            let plan = ScheduledWorkoutPlan(workout: composition, date: dateComponents)
+
+            do {
+                try await WorkoutScheduler.shared.schedule(plan)
+                return [
+                    "success": true,
+                    "id": plan.id.uuidString
+                ]
+            } catch {
+                throw Exception(name: "ScheduleError", description: error.localizedDescription)
+            }
+        }
+
+        // MARK: - Pacer Workout
+
+        AsyncFunction("createPacerWorkout") { (config: [String: Any]) throws -> [String: Any] in
+            guard let activityTypeStr = config["activityType"] as? String,
+                  let activity = self.parseActivityType(activityTypeStr),
+                  let targetConfig = config["target"] as? [String: Any] else {
+                throw Exception(name: "InvalidConfig", description: "Missing required fields: activityType, target")
+            }
+
+            let target = try self.parsePacerTarget(from: targetConfig)
+            let location = self.parseLocationType(config["locationType"] as? String ?? "outdoor") ?? .outdoor
+            let displayName = config["displayName"] as? String
+
+            let workout = PacerWorkout(activity: activity, location: location, target: target, displayName: displayName)
+            let composition = PacerWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+                return [
+                    "valid": true,
+                    "displayName": workout.displayName ?? ""
+                ]
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+        }
+
+        AsyncFunction("schedulePacerWorkout") { (config: [String: Any], date: [String: Any]) throws -> [String: Any] in
+            guard let activityTypeStr = config["activityType"] as? String,
+                  let activity = self.parseActivityType(activityTypeStr),
+                  let targetConfig = config["target"] as? [String: Any] else {
+                throw Exception(name: "InvalidConfig", description: "Missing required fields: activityType, target")
+            }
+
+            let target = try self.parsePacerTarget(from: targetConfig)
+            let location = self.parseLocationType(config["locationType"] as? String ?? "outdoor") ?? .outdoor
+            let displayName = config["displayName"] as? String
+
+            let workout = PacerWorkout(activity: activity, location: location, target: target, displayName: displayName)
+            let composition = PacerWorkoutComposition(workout)
+
+            do {
+                try await composition.validate()
+            } catch {
+                throw Exception(name: "ValidationError", description: error.localizedDescription)
+            }
+
+            let dateComponents = self.parseDateComponents(from: date)
+            let plan = ScheduledWorkoutPlan(workout: composition, date: dateComponents)
+
+            do {
+                try await WorkoutScheduler.shared.schedule(plan)
+                return [
+                    "success": true,
+                    "id": plan.id.uuidString
+                ]
+            } catch {
+                throw Exception(name: "ScheduleError", description: error.localizedDescription)
+            }
+        }
+
+        // MARK: - Activity Types
+
+        Function("getSupportedActivityTypes") { () -> [String] in
+            return [
+                "running",
+                "cycling",
+                "walking",
+                "hiking",
+                "swimming",
+                "rowing",
+                "elliptical",
+                "stairClimbing",
+                "highIntensityIntervalTraining",
+                "yoga",
+                "functionalStrengthTraining",
+                "traditionalStrengthTraining",
+                "dance",
+                "jumpRope",
+                "coreTraining",
+                "pilates",
+                "kickboxing",
+                "stairs",
+                "stepTraining",
+                "wheelchairRunPace",
+                "wheelchairWalkPace"
+            ]
+        }
+
+        Function("getSupportedGoalTypes") { () -> [String] in
+            return [
+                "open",
+                "distance",
+                "time",
+                "energy"
+            ]
+        }
+
+        Function("getSupportedLocationTypes") { () -> [String] in
+            return [
+                "indoor",
+                "outdoor"
+            ]
+        }
+    }
+
+    // MARK: - Helper Methods
+
+    private func authorizationStateToString(_ state: WorkoutScheduler.AuthorizationState) -> String {
+        switch state {
+        case .authorized:
+            return "authorized"
+        case .notDetermined:
+            return "notDetermined"
+        case .denied:
+            return "denied"
+        @unknown default:
+            return "unknown"
+        }
+    }
+
+    private func parseActivityType(_ type: String) -> HKWorkoutActivityType? {
+        switch type.lowercased() {
+        case "running": return .running
+        case "cycling": return .cycling
+        case "walking": return .walking
+        case "hiking": return .hiking
+        case "swimming": return .swimming
+        case "rowing": return .rowing
+        case "elliptical": return .elliptical
+        case "stairclimbing": return .stairClimbing
+        case "highintensityintervaltraining", "hiit": return .highIntensityIntervalTraining
+        case "yoga": return .yoga
+        case "functionalstrengthtraining": return .functionalStrengthTraining
+        case "traditionalstrengthtraining": return .traditionalStrengthTraining
+        case "dance": return .dance
+        case "jumprope": return .jumpRope
+        case "coretraining": return .coreTraining
+        case "pilates": return .pilates
+        case "kickboxing": return .kickboxing
+        case "stairs": return .stairs
+        case "steptraining": return .stepTraining
+        case "wheelchairrunpace": return .wheelchairRunPace
+        case "wheelchairwalkpace": return .wheelchairWalkPace
+        default: return nil
+        }
+    }
+
+    private func parseLocationType(_ type: String?) -> WorkoutLocationType? {
+        guard let type = type else { return .outdoor }
+        switch type.lowercased() {
+        case "indoor": return .indoor
+        case "outdoor": return .outdoor
+        default: return .outdoor
+        }
+    }
+
+    private func parseGoalTypeForValidation(_ type: String) -> WorkoutGoal? {
+        switch type.lowercased() {
+        case "open": return .open
+        case "distance": return .distance(1, .meters)
+        case "time": return .time(1, .seconds)
+        case "energy": return .energy(1, .kilocalories)
+        default: return nil
+        }
+    }
+
+    private func parseWorkoutGoal(from config: [String: Any]) throws -> WorkoutGoal {
+        guard let type = config["type"] as? String else {
+            throw Exception(name: "InvalidGoal", description: "Goal type is required")
+        }
+
+        switch type.lowercased() {
+        case "open":
+            return .open
+
+        case "distance":
+            guard let value = config["value"] as? Double else {
+                throw Exception(name: "InvalidGoal", description: "Distance value is required")
+            }
+            let unitStr = config["unit"] as? String ?? "meters"
+            let unit = self.parseDistanceUnit(unitStr)
+            return .distance(value, unit)
+
+        case "time":
+            guard let value = config["value"] as? Double else {
+                throw Exception(name: "InvalidGoal", description: "Time value is required")
+            }
+            let unitStr = config["unit"] as? String ?? "seconds"
+            let unit = self.parseTimeUnit(unitStr)
+            return .time(value, unit)
+
+        case "energy":
+            guard let value = config["value"] as? Double else {
+                throw Exception(name: "InvalidGoal", description: "Energy value is required")
+            }
+            let unitStr = config["unit"] as? String ?? "kilocalories"
+            let unit = self.parseEnergyUnit(unitStr)
+            return .energy(value, unit)
+
+        default:
+            throw Exception(name: "InvalidGoal", description: "Unknown goal type: \(type)")
+        }
+    }
+
+    private func parseDistanceUnit(_ unit: String) -> UnitLength {
+        switch unit.lowercased() {
+        case "meters", "m": return .meters
+        case "kilometers", "km": return .kilometers
+        case "miles", "mi": return .miles
+        case "yards", "yd": return .yards
+        case "feet", "ft": return .feet
+        default: return .meters
+        }
+    }
+
+    private func parseTimeUnit(_ unit: String) -> UnitDuration {
+        switch unit.lowercased() {
+        case "seconds", "s", "sec": return .seconds
+        case "minutes", "min": return .minutes
+        case "hours", "h", "hr": return .hours
+        default: return .seconds
+        }
+    }
+
+    private func parseEnergyUnit(_ unit: String) -> UnitEnergy {
+        switch unit.lowercased() {
+        case "kilocalories", "kcal", "cal": return .kilocalories
+        case "kilojoules", "kj": return .kilojoules
+        default: return .kilocalories
+        }
+    }
+
+    private func parsePacerTarget(from config: [String: Any]) throws -> PacerWorkout.Target {
+        guard let type = config["type"] as? String else {
+            throw Exception(name: "InvalidTarget", description: "Target type is required")
+        }
+
+        guard let value = config["value"] as? Double else {
+            throw Exception(name: "InvalidTarget", description: "Target value is required")
+        }
+
+        switch type.lowercased() {
+        case "speed":
+            let unitStr = config["unit"] as? String ?? "metersPerSecond"
+            let unit = self.parseSpeedUnit(unitStr)
+            return .speed(value, unit: unit)
+
+        case "pace":
+            let unitStr = config["unit"] as? String ?? "minutesPerKilometer"
+            let unit = self.parsePaceUnit(unitStr)
+            return .pace(time: value, unit: unit)
+
+        default:
+            throw Exception(name: "InvalidTarget", description: "Unknown target type: \(type)")
+        }
+    }
+
+    private func parseSpeedUnit(_ unit: String) -> UnitSpeed {
+        switch unit.lowercased() {
+        case "meterspersecond", "mps", "m/s": return .metersPerSecond
+        case "kilometersperhour", "kph", "km/h": return .kilometersPerHour
+        case "milesperhour", "mph": return .milesPerHour
+        default: return .metersPerSecond
+        }
+    }
+
+    private func parsePaceUnit(_ unit: String) -> UnitLength {
+        switch unit.lowercased() {
+        case "minutesperkilometer", "min/km": return .kilometers
+        case "minutespermile", "min/mi": return .miles
+        default: return .kilometers
+        }
+    }
+
+    private func parseStepPurpose(_ purpose: String) -> IntervalStep.Purpose {
+        switch purpose.lowercased() {
+        case "work": return .work
+        case "recovery": return .recovery
+        default: return .work
+        }
+    }
+
+    private func parseWorkoutAlert(from config: [String: Any]) throws -> WorkoutAlert? {
+        guard let type = config["type"] as? String else {
+            return nil
+        }
+
+        switch type.lowercased() {
+        case "heartrate", "heart_rate":
+            if let zone = config["zone"] as? Int {
+                return .heartRate(zone: zone)
+            } else if let min = config["min"] as? Double, let max = config["max"] as? Double {
+                return .heartRate(Double(min)...Double(max), unit: .beatsPerMinute)
+            }
+
+        case "pace":
+            guard let min = config["min"] as? Double, let max = config["max"] as? Double else {
+                return nil
+            }
+            let unitStr = config["unit"] as? String ?? "minutesPerKilometer"
+            let lengthUnit = self.parsePaceUnit(unitStr)
+            return .pace(min...max, unit: lengthUnit, metric: .current)
+
+        case "speed":
+            guard let min = config["min"] as? Double, let max = config["max"] as? Double else {
+                return nil
+            }
+            let unitStr = config["unit"] as? String ?? "metersPerSecond"
+            let unit = self.parseSpeedUnit(unitStr)
+            return .speed(min...max, unit: unit, metric: .current)
+
+        case "cadence":
+            guard let min = config["min"] as? Double, let max = config["max"] as? Double else {
+                return nil
+            }
+            return .cadence(min...max, unit: .stepsPerMinute, metric: .current)
+
+        case "power":
+            guard let min = config["min"] as? Double, let max = config["max"] as? Double else {
+                return nil
+            }
+            return .power(min...max, unit: .watts, metric: .current)
+
+        default:
+            return nil
+        }
+
+        return nil
+    }
+
+    private func buildCustomWorkout(from config: [String: Any]) throws -> CustomWorkout {
+        guard let activityTypeStr = config["activityType"] as? String,
+              let activity = self.parseActivityType(activityTypeStr) else {
+            throw Exception(name: "InvalidConfig", description: "Invalid or missing activityType")
+        }
+
+        let location = self.parseLocationType(config["locationType"] as? String) ?? .outdoor
+        let displayName = config["displayName"] as? String
+
+        var warmup: WorkoutStep?
+        if let warmupConfig = config["warmup"] as? [String: Any] {
+            warmup = try self.parseWorkoutStep(from: warmupConfig)
+        }
+
+        var cooldown: WorkoutStep?
+        if let cooldownConfig = config["cooldown"] as? [String: Any] {
+            cooldown = try self.parseWorkoutStep(from: cooldownConfig)
+        }
+
+        var blocks: [IntervalBlock] = []
+        if let blocksConfig = config["blocks"] as? [[String: Any]] {
+            for blockConfig in blocksConfig {
+                let block = try self.parseIntervalBlock(from: blockConfig)
+                blocks.append(block)
+            }
+        }
+
+        return CustomWorkout(
+            activity: activity,
+            location: location,
+            displayName: displayName,
+            warmup: warmup,
+            blocks: blocks,
+            cooldown: cooldown
+        )
+    }
+
+    private func parseWorkoutStep(from config: [String: Any]) throws -> WorkoutStep {
+        let goalConfig = config["goal"] as? [String: Any]
+        let goal: WorkoutGoal
+
+        if let goalConfig = goalConfig {
+            goal = try self.parseWorkoutGoal(from: goalConfig)
+        } else {
+            goal = .open
+        }
+
+        var step = WorkoutStep(goal: goal)
+
+        if let alertConfig = config["alert"] as? [String: Any] {
+            step.alert = try self.parseWorkoutAlert(from: alertConfig)
+        }
+
+        return step
+    }
+
+    private func parseIntervalStep(from config: [String: Any]) throws -> IntervalStep {
+        let purposeStr = config["purpose"] as? String ?? "work"
+        let purpose = self.parseStepPurpose(purposeStr)
+
+        var step = IntervalStep(purpose)
+
+        if let goalConfig = config["goal"] as? [String: Any] {
+            step.step.goal = try self.parseWorkoutGoal(from: goalConfig)
+        }
+
+        if let alertConfig = config["alert"] as? [String: Any] {
+            step.step.alert = try self.parseWorkoutAlert(from: alertConfig)
+        }
+
+        return step
+    }
+
+    private func parseIntervalBlock(from config: [String: Any]) throws -> IntervalBlock {
+        var block = IntervalBlock()
+
+        if let iterations = config["iterations"] as? Int {
+            block.iterations = iterations
+        }
+
+        if let stepsConfig = config["steps"] as? [[String: Any]] {
+            var steps: [IntervalStep] = []
+            for stepConfig in stepsConfig {
+                let step = try self.parseIntervalStep(from: stepConfig)
+                steps.append(step)
+            }
+            block.steps = steps
+        }
+
+        return block
+    }
+
+    private func parseDateComponents(from dict: [String: Any]) -> DateComponents {
+        var components = DateComponents()
+
+        if let year = dict["year"] as? Int {
+            components.year = year
+        }
+        if let month = dict["month"] as? Int {
+            components.month = month
+        }
+        if let day = dict["day"] as? Int {
+            components.day = day
+        }
+        if let hour = dict["hour"] as? Int {
+            components.hour = hour
+        }
+        if let minute = dict["minute"] as? Int {
+            components.minute = minute
+        }
+
+        return components
+    }
+
+    private func dateComponentsToDict(_ components: DateComponents) -> [String: Any] {
+        var dict: [String: Any] = [:]
+
+        if let year = components.year {
+            dict["year"] = year
+        }
+        if let month = components.month {
+            dict["month"] = month
+        }
+        if let day = components.day {
+            dict["day"] = day
+        }
+        if let hour = components.hour {
+            dict["hour"] = hour
+        }
+        if let minute = components.minute {
+            dict["minute"] = minute
+        }
+
+        return dict
+    }
+}