@dgpholdings/greatoak-shared 1.2.85 → 1.2.87

package/dist/utils/scoring.utils.js

@@ -1,243 +0,0 @@
-"use strict";
-/*
- * Exercise Scoring System Documentation
- *
- * OVERVIEW:
- * Evaluates workout performance (0-100) with overall score and muscle fatigue ratings.
- * Designed to motivate users by quantifying effort and tracking muscle engagement.
- *
- * SCORE COMPOSITION:
- * - Volume (35%): Total work (weight×reps, duration×difficulty, distance×speed)
- * - Intensity (35%): Effort level (relative weight, rep ranges, speed, RPE when provided)
- * - Quality (30%): Set consistency and performance maintenance
- *
- * SCORE INTERPRETATION:
- * 90-100: Exceptional - peak performance with high volume/intensity/consistency
- * 75-89:  Excellent - strong effort with good form and progression
- * 60-74:  Good - solid baseline performance, room for improvement
- * 45-59:  Moderate - acceptable but consider increasing intensity/volume
- * 0-44:   Light - warm-up sets or recovery day
- *
- * MUSCLE FATIGUE (0-100):
- * Primary muscles get 70% fatigue impact, secondary muscles get 30%
- * 80-100: Fully fatigued - heavily worked, needs recovery
- * 60-79:  High fatigue - significant work, approaching limit
- * 40-59:  Moderate fatigue - good activation, can handle more
- * 20-39:  Light fatigue - warmed up, plenty capacity remaining
- * 0-19:   Minimal fatigue - barely engaged
- *
- * QUALITY SCORE EXPLAINED:
- * Measures how well performance is maintained across sets (starts at 85 points)
- * - Performance drop <10% between sets: +5 points
- * - Performance drop 10-20%: +2 points
- * - Performance drop >30%: -10 points
- * - Consistent RIR/RPE between sets: +3 points
- * - Completing 3+ sets: +5 points, 4+ sets: +8 total points
- *
- * KEY FACTORS:
- * - User fitness level (higher level = higher expectations)
- * - Exercise difficulty (harder exercises boost score)
- * - RPE (1-10): When provided, adjusts intensity (higher RPE = higher intensity)
- * - RIR (0+): When provided, checks consistency between sets
- * - Fatigue multiplier (later sets get 8% bonus per set for accumulated fatigue)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateExerciseScore = void 0;
-const time_util_1 = require("./time.util");
-const scoring_1 = require("./scoring");
-const calculateExerciseScore = (param) => {
-    const { exercise, record, user } = param;
-    // Filter only completed sets
-    const completedSets = record.filter((r) => r.isDone);
-    if (completedSets.length === 0) {
-        return { score: 0, muscleScores: {} };
-    }
-    // Calculate base performance metrics
-    const totalVolume = (0, scoring_1.calculateTotalVolume)(completedSets, user);
-    const avgIntensity = calculateAverageIntensity(completedSets, exercise, user);
-    const setQuality = calculateSetQuality(completedSets);
-    // Calculate muscle fatigue scores
-    const muscleScores = calculateMuscleScores(exercise, completedSets, totalVolume, user);
-    // Final score composition
-    const volumeComponent = normalizeVolume(totalVolume, exercise, user) * 0.35;
-    const intensityComponent = avgIntensity * 0.35;
-    const qualityComponent = setQuality * 0.3;
-    const score = Math.round(volumeComponent + intensityComponent + qualityComponent);
-    return {
-        score: Math.min(100, Math.max(0, score)),
-        muscleScores,
-    };
-};
-exports.calculateExerciseScore = calculateExerciseScore;
-const calculateAverageIntensity = (record, exercise, user) => {
-    const intensities = record.map((set, index) => {
-        let baseIntensity = 0;
-        if (set.type === "weight-reps") {
-            const weight = parseFloat(set.kg) || 0;
-            const reps = parseFloat(set.reps) || 0;
-            const userWeight = user.weightKg || 70;
-            const relativeLoad = weight / userWeight;
-            const repIntensity = getRepIntensity(reps);
-            baseIntensity = (relativeLoad * 40 + repIntensity * 60) / 100;
-            // RPE adjustment (only if provided and valid)
-            if (set.rpe && set.rpe !== "0") {
-                const rpe = parseFloat(set.rpe);
-                if (rpe > 0 && rpe <= 10) {
-                    baseIntensity *= 0.5 + rpe / 20; // Scale from 0.55x to 1.0x
-                }
-            }
-        }
-        else if (set.type === "reps-only") {
-            const reps = parseFloat(set.reps) || 0;
-            baseIntensity = getRepIntensity(reps) / 100;
-            if (set.workDurationSecs) {
-                const tempo = (reps * 3) / set.workDurationSecs;
-                baseIntensity *= Math.min(1.2, Math.max(0.8, tempo));
-            }
-            // RPE adjustment for bodyweight exercises
-            if (set.rpe && set.rpe !== "0") {
-                const rpe = parseFloat(set.rpe);
-                if (rpe > 0 && rpe <= 10) {
-                    baseIntensity *= 0.5 + rpe / 20;
-                }
-            }
-        }
-        else if (set.type === "duration") {
-            const duration = (0, time_util_1.mmssToSecs)(set.durationMmSs);
-            const weight = parseFloat(set.auxWeightKg) || 0;
-            baseIntensity = Math.min(100, duration * 1.5) / 100;
-            if (weight > 0) {
-                baseIntensity *= 1 + weight / 100;
-            }
-        }
-        else if (set.type === "cardio-machine" || set.type === "cardio-free") {
-            const duration = (0, time_util_1.mmssToSecs)(set.durationMmSs);
-            if (set.type === "cardio-machine") {
-                const avgSpeed = (parseFloat(set.speedMin) + parseFloat(set.speedMax)) / 2 || 0;
-                baseIntensity = Math.min(100, avgSpeed * 5.5) / 100;
-            }
-            else {
-                const distance = parseFloat(set.distance) || 0;
-                const speedKmh = duration > 0 ? distance / (duration / 3600) : 0;
-                baseIntensity = Math.min(100, speedKmh * 5.5) / 100;
-            }
-        }
-        // Apply fatigue factor for later sets (8% bonus per set)
-        const fatigueMultiplier = 1 + index * 0.08;
-        return Math.min(100, baseIntensity * fatigueMultiplier * 100);
-    });
-    const avgIntensity = intensities.reduce((a, b) => a + b, 0) / intensities.length;
-    const difficultyBonus = exercise.difficultyLevel * 5;
-    return Math.min(100, avgIntensity + difficultyBonus);
-};
-const calculateSetQuality = (record) => {
-    if (record.length === 0)
-        return 0;
-    if (record.length === 1)
-        return 75;
-    let qualityScore = 85; // Base score
-    // Check performance drop-off between sets
-    for (let i = 1; i < record.length; i++) {
-        const curr = record[i];
-        const prev = record[i - 1];
-        if (curr.type === "weight-reps" && prev.type === "weight-reps") {
-            const currWork = parseFloat(curr.reps) * parseFloat(curr.kg);
-            const prevWork = parseFloat(prev.reps) * parseFloat(prev.kg);
-            const dropOff = prevWork > 0 ? 1 - currWork / prevWork : 0;
-            if (dropOff < 0.1)
-                qualityScore += 5; // Excellent maintenance
-            else if (dropOff < 0.2)
-                qualityScore += 2; // Good maintenance
-            else if (dropOff > 0.3)
-                qualityScore -= 10; // Poor pacing
-        }
-        else if (curr.type === "reps-only" && prev.type === "reps-only") {
-            const currReps = parseFloat(curr.reps);
-            const prevReps = parseFloat(prev.reps);
-            const dropOff = prevReps > 0 ? 1 - currReps / prevReps : 0;
-            if (dropOff < 0.15)
-                qualityScore += 5;
-            else if (dropOff > 0.3)
-                qualityScore -= 8;
-        }
-        // Check effort consistency using either RIR or RPE (whichever is provided)
-        // RIR consistency check
-        if ("rir" in curr &&
-            "rir" in prev &&
-            curr.rir &&
-            prev.rir &&
-            curr.rir !== "0" &&
-            prev.rir !== "0") {
-            const currRir = parseFloat(curr.rir);
-            const prevRir = parseFloat(prev.rir);
-            if (!isNaN(currRir) && !isNaN(prevRir)) {
-                const rirDiff = Math.abs(currRir - prevRir);
-                if (rirDiff <= 1)
-                    qualityScore += 3; // Consistent effort
-            }
-        }
-        // RPE consistency check (alternative to RIR)
-        else if (curr.rpe && prev.rpe && curr.rpe !== "0" && prev.rpe !== "0") {
-            const currRpe = parseFloat(curr.rpe);
-            const prevRpe = parseFloat(prev.rpe);
-            if (!isNaN(currRpe) && !isNaN(prevRpe)) {
-                const rpeDiff = Math.abs(currRpe - prevRpe);
-                if (rpeDiff <= 1)
-                    qualityScore += 3; // Consistent effort
-            }
-        }
-    }
-    // Bonus for multiple quality sets
-    if (record.length >= 3)
-        qualityScore += 5;
-    if (record.length >= 4)
-        qualityScore += 3;
-    return Math.min(100, Math.max(0, qualityScore));
-};
-const calculateMuscleScores = (exercise, record, totalVolume, user) => {
-    const muscleScores = {};
-    const volumePerSet = totalVolume / record.length;
-    // Normalize volume by bodyweight if available
-    const normalizedVolumePerSet = user.weightKg
-        ? volumePerSet / (user.weightKg * 10)
-        : volumePerSet / 500; // Fallback to absolute scale
-    // Primary muscles take 70% of the fatigue
-    exercise.primaryMuscles.forEach((muscle) => {
-        const baseFatigue = Math.min(100, normalizedVolumePerSet * 70);
-        const setMultiplier = Math.min(1.5, 1 + (record.length - 1) * 0.15);
-        muscleScores[muscle] = Math.min(100, baseFatigue * setMultiplier);
-    });
-    // Secondary muscles take 30% of the fatigue
-    exercise.secondaryMuscles.forEach((muscle) => {
-        const baseFatigue = Math.min(100, normalizedVolumePerSet * 30);
-        const setMultiplier = Math.min(1.3, 1 + (record.length - 1) * 0.1);
-        muscleScores[muscle] = Math.min(100, baseFatigue * setMultiplier);
-    });
-    return muscleScores;
-};
-const normalizeVolume = (totalVolume, exercise, user) => {
-    const userWeight = user.weightKg || 70;
-    const fitnessLevel = user.fitnessLevel || 2;
-    // Expected volume baseline
-    const baseExpected = userWeight * 15 * fitnessLevel;
-    const difficultyAdjustment = 1 + exercise.difficultyLevel / 8;
-    const expectedVolume = baseExpected * difficultyAdjustment;
-    // Sigmoid normalization for smooth scoring
-    const ratio = totalVolume / expectedVolume;
-    return 100 / (1 + Math.exp(-3 * (ratio - 0.8)));
-};
-const getRepIntensity = (reps) => {
-    if (reps <= 3)
-        return 95;
-    if (reps <= 5)
-        return 87;
-    if (reps <= 8)
-        return 80;
-    if (reps <= 12)
-        return 70;
-    if (reps <= 15)
-        return 65;
-    if (reps <= 20)
-        return 60;
-    return 50;
-};