@dgpholdings/greatoak-shared 1.1.60 → 1.1.62

package/dist/utils/workoutSummary.util.js

@@ -6,342 +6,405 @@ const scoring_utils_1 = require("./scoring.utils");
  * Calculate comprehensive workout summary
  */
 const calculateWorkoutSummary = (exercises, userProfile) => {
-    var _a, _b;
-    let totalScore = 0;
-    let totalCalories = 0;
-    let totalEpocCalories = 0;
-    let totalSets = 0;
-    const exerciseSummaries = [];
-    const muscleStressMap = new Map();
-    // Calculate workout duration
-    const workoutStart = ((_a = exercises[0]) === null || _a === void 0 ? void 0 : _a.startTime) || new Date();
-    const workoutEnd = ((_b = exercises[exercises.length - 1]) === null || _b === void 0 ? void 0 : _b.endTime) || new Date();
-    const workoutDuration = Math.max(1, (workoutEnd.getTime() - workoutStart.getTime()) / (1000 * 60));
-    // Process each exercise
-    exercises.forEach((exerciseData) => {
-        const { exercise, records } = exerciseData;
-        const sets = [];
-        let exerciseScore = 0;
-        let exerciseCalories = 0;
-        let bestSetScore = 0;
-        let bestSetNumber = 1;
-        let bestSetReason = "highest score";
-        // Process each set/record
-        records.forEach((record, index) => {
-            if (!record.isDone)
-                return;
-            const scoreBreakdown = (0, scoring_utils_1.computeScoreFromRecord)({
-                record,
-                exercise,
-                userProfile,
-                isTimeIntervalModeEnabled: !!(record.workDurationSecs && record.restDurationSecs),
-            });
-            const setNumber = index + 1;
-            const setDescription = generateSetDescription(record, exercise, scoreBreakdown);
-            sets.push({
-                setNumber,
-                record,
-                scoreBreakdown,
-                description: setDescription,
-            });
-            exerciseScore += scoreBreakdown.finalScore;
-            exerciseCalories += scoreBreakdown.caloriesBurned;
-            totalSets++;
-            // Track best set
-            if (scoreBreakdown.finalScore > bestSetScore) {
-                bestSetScore = scoreBreakdown.finalScore;
-                bestSetNumber = setNumber;
-                bestSetReason = getBestSetReason(record, exercise);
-            }
-            // Accumulate muscle stress
-            exercise.primaryMuscles.forEach((muscle) => {
-                const currentStress = muscleStressMap.get(muscle) || 0;
-                muscleStressMap.set(muscle, currentStress + scoreBreakdown.finalScore * 1.0); // Primary muscles get full stress
-            });
-            exercise.secondaryMuscles.forEach((muscle) => {
-                const currentStress = muscleStressMap.get(muscle) || 0;
-                muscleStressMap.set(muscle, currentStress + scoreBreakdown.finalScore * 0.6); // Secondary muscles get 60% stress
-            });
-        });
-        if (sets.length > 0) {
-            exerciseSummaries.push({
-                exercise,
-                sets,
-                totalScore: exerciseScore,
-                averageScore: exerciseScore / sets.length,
-                totalCalories: exerciseCalories,
-                bestSet: {
-                    setNumber: bestSetNumber,
-                    score: bestSetScore,
-                    reason: bestSetReason,
-                },
-                muscleActivation: calculateMuscleActivation(exercise, sets),
-            });
-        }
+  var _a, _b;
+  let totalScore = 0;
+  let totalCalories = 0;
+  let totalEpocCalories = 0;
+  let totalSets = 0;
+  const exerciseSummaries = [];
+  const muscleStressMap = new Map();
+  // Calculate workout duration
+  const workoutStart =
+    ((_a = exercises[0]) === null || _a === void 0 ? void 0 : _a.startTime) ||
+    new Date();
+  const workoutEnd =
+    ((_b = exercises[exercises.length - 1]) === null || _b === void 0
+      ? void 0
+      : _b.endTime) || new Date();
+  const workoutDuration = Math.max(
+    1,
+    (workoutEnd.getTime() - workoutStart.getTime()) / (1000 * 60)
+  );
+  // Process each exercise
+  exercises.forEach((exerciseData) => {
+    const { exercise, records } = exerciseData;
+    const sets = [];
+    let exerciseScore = 0;
+    let exerciseCalories = 0;
+    let bestSetScore = 0;
+    let bestSetNumber = 1;
+    let bestSetReason = "highest score";
+    // Process each set/record
+    records.forEach((record, index) => {
+      if (!record.isDone) return;
+      const scoreBreakdown = (0, scoring_utils_1.computeScoreFromRecord)({
+        record,
+        exercise,
+        userProfile,
+        isTimeIntervalModeEnabled: !!(
+          record.workDurationSecs && record.restDurationSecs
+        ),
+      });
+      const setNumber = index + 1;
+      const setDescription = generateSetDescription(
+        record,
+        exercise,
+        scoreBreakdown
+      );
+      sets.push({
+        setNumber,
+        record,
+        scoreBreakdown,
+        description: setDescription,
+      });
+      exerciseScore += scoreBreakdown.finalScore;
+      exerciseCalories += scoreBreakdown.caloriesBurned;
+      totalSets++;
+      // Track best set
+      if (scoreBreakdown.finalScore > bestSetScore) {
+        bestSetScore = scoreBreakdown.finalScore;
+        bestSetNumber = setNumber;
+        bestSetReason = getBestSetReason(record, exercise);
+      }
+      // Accumulate muscle stress
+      exercise.primaryMuscles.forEach((muscle) => {
+        const currentStress = muscleStressMap.get(muscle) || 0;
+        muscleStressMap.set(
+          muscle,
+          currentStress + scoreBreakdown.finalScore * 1.0
+        ); // Primary muscles get full stress
+      });
+      exercise.secondaryMuscles.forEach((muscle) => {
+        const currentStress = muscleStressMap.get(muscle) || 0;
+        muscleStressMap.set(
+          muscle,
+          currentStress + scoreBreakdown.finalScore * 0.6
+        ); // Secondary muscles get 60% stress
+      });
     });
-    // Calculate totals
-    totalScore = exerciseSummaries.reduce((sum, ex) => sum + ex.totalScore, 0);
-    totalCalories = exerciseSummaries.reduce((sum, ex) => sum + ex.totalCalories, 0);
-    totalEpocCalories = exerciseSummaries.reduce((sum, ex) => sum +
-        ex.sets.reduce((setSum, set) => setSum + set.scoreBreakdown.epocCalories, 0), 0);
-    // Calculate muscle recovery
-    const muscleRecovery = calculateMuscleRecovery(muscleStressMap, exercises);
-    // Determine overall fatigue level
-    const averageScore = totalSets > 0 ? totalScore / totalSets : 0;
-    const fatigueLevel = getFatigueLevel(averageScore, totalScore, workoutDuration, userProfile);
-    const recommendedRestDays = getRecommendedRestDays(fatigueLevel, muscleRecovery);
-    return {
-        totalScore: Math.round(totalScore),
-        averageScore: Math.round(averageScore),
-        totalCalories: Math.round(totalCalories),
-        totalEpocCalories: Math.round(totalEpocCalories),
-        workoutDuration: Math.round(workoutDuration),
-        exerciseSummaries,
-        muscleRecovery,
-        fatigueLevel,
-        recommendedRestDays,
-    };
+    if (sets.length > 0) {
+      exerciseSummaries.push({
+        exercise,
+        sets,
+        totalScore: exerciseScore,
+        averageScore: exerciseScore / sets.length,
+        totalCalories: exerciseCalories,
+        bestSet: {
+          setNumber: bestSetNumber,
+          score: bestSetScore,
+          reason: bestSetReason,
+        },
+        muscleActivation: calculateMuscleActivation(exercise, sets),
+      });
+    }
+  });
+  // Calculate totals
+  totalScore = exerciseSummaries.reduce((sum, ex) => sum + ex.totalScore, 0);
+  totalCalories = exerciseSummaries.reduce(
+    (sum, ex) => sum + ex.totalCalories,
+    0
+  );
+  totalEpocCalories = exerciseSummaries.reduce(
+    (sum, ex) =>
+      sum +
+      ex.sets.reduce(
+        (setSum, set) => setSum + set.scoreBreakdown.epocCalories,
+        0
+      ),
+    0
+  );
+  // Calculate muscle recovery
+  const muscleRecovery = calculateMuscleRecovery(muscleStressMap, exercises);
+  // Determine overall fatigue level
+  const averageScore = totalSets > 0 ? totalScore / totalSets : 0;
+  const fatigueLevel = getFatigueLevel(
+    averageScore,
+    totalScore,
+    workoutDuration,
+    userProfile
+  );
+  const recommendedRestDays = getRecommendedRestDays(
+    fatigueLevel,
+    muscleRecovery
+  );
+  return {
+    totalScore: Math.round(totalScore),
+    averageScore: Math.round(averageScore),
+    totalCalories: Math.round(totalCalories),
+    totalEpocCalories: Math.round(totalEpocCalories),
+    workoutDuration: Math.round(workoutDuration),
+    exerciseSummaries,
+    muscleRecovery,
+    fatigueLevel,
+    recommendedRestDays,
+  };
 };
 exports.calculateWorkoutSummary = calculateWorkoutSummary;
 /**
  * Generate human-readable set description
  */
 const generateSetDescription = (record, exercise, scoreBreakdown) => {
-    var _a;
-    const effort = record.rpe
-        ? `RPE ${record.rpe}`
-        : "rir" in record && record.rir
-            ? `${record.rir} RIR`
-            : "";
-    const calories = `${Math.round(scoreBreakdown.caloriesBurned)} cal`;
-    switch (record.type) {
-        case "weight-reps":
-            return `${record.kg}kg × ${record.reps} reps ${effort} • ${calories}`;
-        case "reps-only":
-            const auxWeight = record.auxWeightKg ? ` (+${record.auxWeightKg}kg)` : "";
-            return `${record.reps} reps${auxWeight} ${effort} • ${calories}`;
-        case "duration":
-            const auxWeightDur = record.auxWeightKg
-                ? ` (+${record.auxWeightKg}kg)`
-                : "";
-            const minutes = Math.floor(record.durationSecs / 60);
-            const seconds = record.durationSecs % 60;
-            const timeStr = minutes > 0
-                ? `${minutes}:${seconds < 10 ? `0${seconds}` : `${seconds}`}`
-                : `${seconds}s`;
-            return `${timeStr}${auxWeightDur} ${effort} • ${calories}`;
-        case "cardio-machine":
-            const rpe = (_a = record.rpe) !== null && _a !== void 0 ? _a : 1;
-            const resistance = rpe > 0 ? ` R${rpe}` : "";
-            const minutes_cm = Math.floor(record.durationSecs / 60);
-            const seconds_cm = record.durationSecs % 60;
-            const timeStr_cm = minutes_cm > 0
-                ? `${minutes_cm}:${seconds_cm < 10 ? `0${seconds_cm}` : `${seconds_cm}`}`
-                : `${seconds_cm}s`;
-            return `${record.speed} speed${resistance} × ${timeStr_cm} ${effort} • ${calories}`;
-        case "cardio-free":
-            const minutes_cf = Math.floor(record.durationSecs / 60);
-            const seconds_cf = record.durationSecs % 60;
-            const timeStr_cf = minutes_cf > 0
-                ? `${minutes_cf}:${seconds_cf < 10 ? `0${seconds_cf}` : `${seconds_cf}`}`
-                : `${seconds_cf}s`;
-            let pace = "";
-            if ("avgPaceSecsPerKm" in record && record.avgPaceSecsPerKm) {
-                const paceMinutes = Math.floor(record.avgPaceSecsPerKm / 60);
-                const paceSeconds = Math.round(record.avgPaceSecsPerKm % 60);
-                const paceSecondsFormatted = paceSeconds < 10 ? `0${paceSeconds}` : `${paceSeconds}`;
-                pace = ` (${paceMinutes}:${paceSecondsFormatted}/km)`;
-            }
-            return `${record.distance}km in ${timeStr_cf}${pace} ${effort} • ${calories}`;
-        default:
-            return `${effort} • ${calories}`;
-    }
+  var _a;
+  const effort = record.rpe
+    ? `RPE ${record.rpe}`
+    : "rir" in record && record.rir
+    ? `${record.rir} RIR`
+    : "";
+  const calories = `${Math.round(scoreBreakdown.caloriesBurned)} cal`;
+  switch (record.type) {
+    case "weight-reps":
+      return `${record.kg}kg × ${record.reps} reps ${effort} • ${calories}`;
+    case "reps-only":
+      const auxWeight = record.auxWeightKg ? ` (+${record.auxWeightKg}kg)` : "";
+      return `${record.reps} reps${auxWeight} ${effort} • ${calories}`;
+    case "duration":
+      const auxWeightDur = record.auxWeightKg
+        ? ` (+${record.auxWeightKg}kg)`
+        : "";
+      const minutes = Math.floor(record.durationMmSs / 60);
+      const seconds = record.durationMmSs % 60;
+      const timeStr =
+        minutes > 0
+          ? `${minutes}:${seconds < 10 ? `0${seconds}` : `${seconds}`}`
+          : `${seconds}s`;
+      return `${timeStr}${auxWeightDur} ${effort} • ${calories}`;
+    case "cardio-machine":
+      const rpe = (_a = record.rpe) !== null && _a !== void 0 ? _a : 1;
+      const resistance = rpe > 0 ? ` R${rpe}` : "";
+      const minutes_cm = Math.floor(record.durationMmSs / 60);
+      const seconds_cm = record.durationMmSs % 60;
+      const timeStr_cm =
+        minutes_cm > 0
+          ? `${minutes_cm}:${
+              seconds_cm < 10 ? `0${seconds_cm}` : `${seconds_cm}`
+            }`
+          : `${seconds_cm}s`;
+      return `${record.speed} speed${resistance} × ${timeStr_cm} ${effort} • ${calories}`;
+    case "cardio-free":
+      const minutes_cf = Math.floor(record.durationMmSs / 60);
+      const seconds_cf = record.durationMmSs % 60;
+      const timeStr_cf =
+        minutes_cf > 0
+          ? `${minutes_cf}:${
+              seconds_cf < 10 ? `0${seconds_cf}` : `${seconds_cf}`
+            }`
+          : `${seconds_cf}s`;
+      let pace = "";
+      if ("avgPaceSecsPerKm" in record && record.avgPaceSecsPerKm) {
+        const paceMinutes = Math.floor(record.avgPaceSecsPerKm / 60);
+        const paceSeconds = Math.round(record.avgPaceSecsPerKm % 60);
+        const paceSecondsFormatted =
+          paceSeconds < 10 ? `0${paceSeconds}` : `${paceSeconds}`;
+        pace = ` (${paceMinutes}:${paceSecondsFormatted}/km)`;
+      }
+      return `${record.distance}km in ${timeStr_cf}${pace} ${effort} • ${calories}`;
+    default:
+      return `${effort} • ${calories}`;
+  }
 };
 /**
  * Determine reason for best set
  */
 const getBestSetReason = (record, exercise) => {
-    switch (record.type) {
-        case "weight-reps":
-            return "heaviest weight";
-        case "reps-only":
-            return "most reps";
-        case "duration":
-            return "longest hold";
-        case "cardio-machine":
-            return "highest intensity";
-        case "cardio-free":
-            return "fastest pace";
-        default:
-            return "highest effort";
-    }
+  switch (record.type) {
+    case "weight-reps":
+      return "heaviest weight";
+    case "reps-only":
+      return "most reps";
+    case "duration":
+      return "longest hold";
+    case "cardio-machine":
+      return "highest intensity";
+    case "cardio-free":
+      return "fastest pace";
+    default:
+      return "highest effort";
+  }
 };
 /**
  * Calculate muscle activation levels
  */
 const calculateMuscleActivation = (exercise, sets) => {
-    if (sets.length === 0)
-        return { primary: 0, secondary: 0 };
-    const avgScore = sets.reduce((sum, set) => sum + set.scoreBreakdown.finalScore, 0) /
-        sets.length;
-    const maxPossibleScore = 100; // Reference point
-    // Activation based on exercise difficulty and average set score
-    const baseActivation = Math.min(100, (avgScore / maxPossibleScore) * 100);
-    const difficultyBonus = exercise.difficultyLevel * 2; // Up to 20% bonus
-    return {
-        primary: Math.min(100, Math.round(baseActivation + difficultyBonus)),
-        secondary: Math.min(100, Math.round((baseActivation + difficultyBonus) * 0.7)), // 70% of primary
-    };
+  if (sets.length === 0) return { primary: 0, secondary: 0 };
+  const avgScore =
+    sets.reduce((sum, set) => sum + set.scoreBreakdown.finalScore, 0) /
+    sets.length;
+  const maxPossibleScore = 100; // Reference point
+  // Activation based on exercise difficulty and average set score
+  const baseActivation = Math.min(100, (avgScore / maxPossibleScore) * 100);
+  const difficultyBonus = exercise.difficultyLevel * 2; // Up to 20% bonus
+  return {
+    primary: Math.min(100, Math.round(baseActivation + difficultyBonus)),
+    secondary: Math.min(
+      100,
+      Math.round((baseActivation + difficultyBonus) * 0.7)
+    ), // 70% of primary
+  };
 };
 /**
  * Calculate muscle recovery times
  */
 const calculateMuscleRecovery = (muscleStressMap, exercises) => {
-    const recovery = {};
-    muscleStressMap.forEach((totalStress, muscle) => {
-        // Base recovery time based on muscle group
-        const baseRecovery = getMuscleBaseRecovery(muscle);
-        // Stress level (0-100)
-        const fatigueLevel = Math.min(100, (totalStress / 200) * 100); // 200 = very high stress threshold
-        // Recovery time increases with fatigue level
-        let recoveryHours = baseRecovery;
-        if (fatigueLevel > 80)
-            recoveryHours *= 1.5; // 50% longer for high fatigue
-        else if (fatigueLevel > 60)
-            recoveryHours *= 1.3; // 30% longer for moderate-high fatigue
-        else if (fatigueLevel > 40)
-            recoveryHours *= 1.1; // 10% longer for moderate fatigue
-        // Find exercises that worked this muscle - using manual search instead of includes
-        const involvedExercises = [];
-        exercises.forEach(({ exercise }) => {
-            let found = false;
-            // Check primary muscles
-            for (let i = 0; i < exercise.primaryMuscles.length; i++) {
-                if (exercise.primaryMuscles[i] === muscle) {
-                    found = true;
-                    break;
-                }
-            }
-            // Check secondary muscles if not found in primary
-            if (!found) {
-                for (let i = 0; i < exercise.secondaryMuscles.length; i++) {
-                    if (exercise.secondaryMuscles[i] === muscle) {
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            if (found) {
-                involvedExercises.push(exercise.name);
-            }
-        });
-        recovery[muscle] = {
-            fatigueLevel: Math.round(fatigueLevel),
-            recoveryHours: Math.round(recoveryHours),
-            trainingStress: Math.round(totalStress),
-            exercises: involvedExercises,
-        };
+  const recovery = {};
+  muscleStressMap.forEach((totalStress, muscle) => {
+    // Base recovery time based on muscle group
+    const baseRecovery = getMuscleBaseRecovery(muscle);
+    // Stress level (0-100)
+    const fatigueLevel = Math.min(100, (totalStress / 200) * 100); // 200 = very high stress threshold
+    // Recovery time increases with fatigue level
+    let recoveryHours = baseRecovery;
+    if (fatigueLevel > 80) recoveryHours *= 1.5; // 50% longer for high fatigue
+    else if (fatigueLevel > 60)
+      recoveryHours *= 1.3; // 30% longer for moderate-high fatigue
+    else if (fatigueLevel > 40) recoveryHours *= 1.1; // 10% longer for moderate fatigue
+    // Find exercises that worked this muscle - using manual search instead of includes
+    const involvedExercises = [];
+    exercises.forEach(({ exercise }) => {
+      let found = false;
+      // Check primary muscles
+      for (let i = 0; i < exercise.primaryMuscles.length; i++) {
+        if (exercise.primaryMuscles[i] === muscle) {
+          found = true;
+          break;
+        }
+      }
+      // Check secondary muscles if not found in primary
+      if (!found) {
+        for (let i = 0; i < exercise.secondaryMuscles.length; i++) {
+          if (exercise.secondaryMuscles[i] === muscle) {
+            found = true;
+            break;
+          }
+        }
+      }
+      if (found) {
+        involvedExercises.push(exercise.name);
+      }
     });
-    return recovery;
+    recovery[muscle] = {
+      fatigueLevel: Math.round(fatigueLevel),
+      recoveryHours: Math.round(recoveryHours),
+      trainingStress: Math.round(totalStress),
+      exercises: involvedExercises,
+    };
+  });
+  return recovery;
 };
 /**
  * Get base recovery time for different muscle groups
  */
 const getMuscleBaseRecovery = (muscle) => {
-    // Recovery times in hours based on muscle size and recovery capacity
-    const recoveryTimes = {
-        "pectoralis-major": 48,
-        "pectoralis-minor": 48,
-        "latissimus-dorsi": 48,
-        trapezius: 36,
-        rhomboids: 36,
-        "deltoids-anterior": 36,
-        "deltoids-middle": 36,
-        "bicep-short-inner": 24,
-        "bicep-long-outer": 24,
-        "tricep-brachii-long": 24,
-        "tricep-brachii-lateral": 24,
-        quadriceps: 48,
-        hamstrings: 48,
-        "maximus-lower": 48,
-        "medius-upper": 36,
-        "calf-inner": 24,
-        "calf-outer": 24,
-        "abs-upper": 24,
-        "abs-lower": 24,
-        obliques: 24,
-        "lower-back": 48,
-        "fore-arm-inner": 18,
-        "fore-arm-outer": 18,
-    };
-    return recoveryTimes[muscle] || 36; // Default 36 hours
+  // Recovery times in hours based on muscle size and recovery capacity
+  const recoveryTimes = {
+    "pectoralis-major": 48,
+    "pectoralis-minor": 48,
+    "latissimus-dorsi": 48,
+    trapezius: 36,
+    rhomboids: 36,
+    "deltoids-anterior": 36,
+    "deltoids-middle": 36,
+    "bicep-short-inner": 24,
+    "bicep-long-outer": 24,
+    "tricep-brachii-long": 24,
+    "tricep-brachii-lateral": 24,
+    quadriceps: 48,
+    hamstrings: 48,
+    "maximus-lower": 48,
+    "medius-upper": 36,
+    "calf-inner": 24,
+    "calf-outer": 24,
+    "abs-upper": 24,
+    "abs-lower": 24,
+    obliques: 24,
+    "lower-back": 48,
+    "fore-arm-inner": 18,
+    "fore-arm-outer": 18,
+  };
+  return recoveryTimes[muscle] || 36; // Default 36 hours
 };
 /**
  * Determine overall fatigue level
  */
-const getFatigueLevel = (averageScore, totalScore, workoutDuration, userProfile) => {
-    const fitnessAdjustment = (userProfile === null || userProfile === void 0 ? void 0 : userProfile.fitnessLevel)
-        ? (userProfile.fitnessLevel - 3) * 0.1 // ±20% based on fitness level
-        : 0;
-    const intensity = averageScore * (1 - fitnessAdjustment);
-    const volume = totalScore / 100; // Normalize volume
-    const density = totalScore / workoutDuration; // Score per minute
-    if (intensity > 80 || volume > 15 || density > 8)
-        return "extreme";
-    if (intensity > 65 || volume > 12 || density > 6)
-        return "very_hard";
-    if (intensity > 50 || volume > 8 || density > 4)
-        return "hard";
-    if (intensity > 35 || volume > 5 || density > 2)
-        return "moderate";
-    return "light";
+const getFatigueLevel = (
+  averageScore,
+  totalScore,
+  workoutDuration,
+  userProfile
+) => {
+  const fitnessAdjustment = (
+    userProfile === null || userProfile === void 0
+      ? void 0
+      : userProfile.fitnessLevel
+  )
+    ? (userProfile.fitnessLevel - 3) * 0.1 // ±20% based on fitness level
+    : 0;
+  const intensity = averageScore * (1 - fitnessAdjustment);
+  const volume = totalScore / 100; // Normalize volume
+  const density = totalScore / workoutDuration; // Score per minute
+  if (intensity > 80 || volume > 15 || density > 8) return "extreme";
+  if (intensity > 65 || volume > 12 || density > 6) return "very_hard";
+  if (intensity > 50 || volume > 8 || density > 4) return "hard";
+  if (intensity > 35 || volume > 5 || density > 2) return "moderate";
+  return "light";
 };
 /**
  * Get recommended rest days based on fatigue
  */
 const getRecommendedRestDays = (fatigueLevel, muscleRecovery) => {
-    // Base rest days by fatigue level
-    const baseDays = {
-        light: 0,
-        moderate: 1,
-        hard: 1,
-        very_hard: 2,
-        extreme: 3,
-    };
-    const restDays = baseDays[fatigueLevel];
-    // Consider muscle recovery times - using manual iteration
-    const recoveryHours = [];
-    for (const muscle in muscleRecovery) {
-        if (muscleRecovery.hasOwnProperty(muscle)) {
-            recoveryHours.push(muscleRecovery[muscle].recoveryHours);
-        }
+  // Base rest days by fatigue level
+  const baseDays = {
+    light: 0,
+    moderate: 1,
+    hard: 1,
+    very_hard: 2,
+    extreme: 3,
+  };
+  const restDays = baseDays[fatigueLevel];
+  // Consider muscle recovery times - using manual iteration
+  const recoveryHours = [];
+  for (const muscle in muscleRecovery) {
+    if (muscleRecovery.hasOwnProperty(muscle)) {
+      recoveryHours.push(muscleRecovery[muscle].recoveryHours);
     }
-    let maxRecoveryHours = 0;
-    for (let i = 0; i < recoveryHours.length; i++) {
-        if (recoveryHours[i] > maxRecoveryHours) {
-            maxRecoveryHours = recoveryHours[i];
-        }
+  }
+  let maxRecoveryHours = 0;
+  for (let i = 0; i < recoveryHours.length; i++) {
+    if (recoveryHours[i] > maxRecoveryHours) {
+      maxRecoveryHours = recoveryHours[i];
     }
-    const muscleBasedDays = Math.ceil(maxRecoveryHours / 24);
-    return Math.max(restDays, muscleBasedDays);
+  }
+  const muscleBasedDays = Math.ceil(maxRecoveryHours / 24);
+  return Math.max(restDays, muscleBasedDays);
 };
 /**
  * Generate user-friendly workout summary text
  */
 const generateWorkoutSummaryText = (summary) => {
-    const { totalScore, averageScore, totalCalories, totalEpocCalories, workoutDuration, fatigueLevel, recommendedRestDays, exerciseSummaries, } = summary;
-    const intensityMap = {
-        light: "Light workout",
-        moderate: "Moderate workout",
-        hard: "Hard workout",
-        very_hard: "Very hard workout",
-        extreme: "Extreme workout",
-    };
-    const intensityText = intensityMap[fatigueLevel];
-    const restText = recommendedRestDays === 0
-        ? "You can train again tomorrow"
-        : `Recommended rest: ${recommendedRestDays} day${recommendedRestDays > 1 ? "s" : ""}`;
-    return `
+  const {
+    totalScore,
+    averageScore,
+    totalCalories,
+    totalEpocCalories,
+    workoutDuration,
+    fatigueLevel,
+    recommendedRestDays,
+    exerciseSummaries,
+  } = summary;
+  const intensityMap = {
+    light: "Light workout",
+    moderate: "Moderate workout",
+    hard: "Hard workout",
+    very_hard: "Very hard workout",
+    extreme: "Extreme workout",
+  };
+  const intensityText = intensityMap[fatigueLevel];
+  const restText =
+    recommendedRestDays === 0
+      ? "You can train again tomorrow"
+      : `Recommended rest: ${recommendedRestDays} day${
+          recommendedRestDays > 1 ? "s" : ""
+        }`;
+  return `
 🏋️ **${intensityText}** (Score: ${totalScore})
 ⏱️ Duration: ${workoutDuration} minutes
 🔥 Calories: ${totalCalories} + ${totalEpocCalories} afterburn
@@ -349,8 +412,13 @@ const generateWorkoutSummaryText = (summary) => {
 
 💪 **Exercises completed:**
 ${exerciseSummaries
-        .map((ex) => `• ${ex.exercise.name}: ${ex.sets.length} sets (${Math.round(ex.totalScore)} pts)`)
-        .join("\n")}
+  .map(
+    (ex) =>
+      `• ${ex.exercise.name}: ${ex.sets.length} sets (${Math.round(
+        ex.totalScore
+      )} pts)`
+  )
+  .join("\n")}
 
 🛌 **Recovery:** ${restText}
   `.trim();