@dgpholdings/greatoak-shared 1.1.35 → 1.1.36

package/dist/types/TApiExerciseRecord.d.ts

@@ -2,7 +2,8 @@ export type TRecord = {
     isDone: boolean;
     rpe?: string;
     setNote?: string;
-    restInBetweenDurationSecs?: string;
+    workDurationSecs?: number;
+    restDurationSecs?: number;
 } & ({
     type: "weight-reps";
     kg: string;
@@ -41,7 +42,7 @@ export type TRecordConfig = {
     enableRpe?: boolean;
     enableSetNote?: boolean;
     enableExerciseNote?: boolean;
-    enableRestTime?: boolean;
+    enableTimeIntervalMode?: boolean;
 };
 export type TApiExerciseRecordUpdateReq = {
     templateId: string;

package/dist/utils/record.utils.d.ts

@@ -3,7 +3,8 @@ type RefinedBase = {
     isDone: boolean;
     rpe?: number;
     rir?: number;
-    restInBetweenDurationSecs?: number;
+    workDurationSecs?: number;
+    restDurationSecs?: number;
     setNote?: string;
 };
 export type TRefinedWeightRecord = RefinedBase & {
@@ -21,6 +22,12 @@ export type TRefinedBodyWeightRecord = RefinedBase & {
     reps: number;
     auxWeightKg?: number;
 };
-export type TRefinedRecord = TRefinedWeightRecord | TRefinedDurationRecord | TRefinedBodyWeightRecord;
+export type TRefinedDistanceRecord = RefinedBase & {
+    type: "distance";
+    distanceKm: number;
+    durationSecs: string;
+    avgPaceSecsPerKm?: number;
+};
+export type TRefinedRecord = TRefinedWeightRecord | TRefinedDurationRecord | TRefinedBodyWeightRecord | TRefinedDistanceRecord;
 export declare const refineRecordEntry: (entry: TRecord) => TRefinedRecord;
 export {};

package/dist/utils/record.utils.js

@@ -4,9 +4,11 @@ exports.refineRecordEntry = void 0;
 const isDefined_utils_1 = require("./isDefined.utils");
 const number_util_1 = require("./number.util");
 const refineRecordEntry = (entry) => {
-    var _a, _b, _c;
-    const base = Object.assign(Object.assign(Object.assign({ isDone: entry.isDone }, ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rpe)) && { rpe: (0, number_util_1.toNumber)(entry.rpe) })), ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.restInBetweenDurationSecs)) && {
-        restInBetweenDurationSecs: (0, number_util_1.toNumber)(entry.restInBetweenDurationSecs),
+    var _a, _b, _c, _d, _e;
+    const base = Object.assign(Object.assign(Object.assign(Object.assign({ isDone: entry.isDone }, ((0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rpe)) && { rpe: (0, number_util_1.toNumber)(entry.rpe) })), ((0, isDefined_utils_1.isDefinedNumber)(entry.workDurationSecs) && {
+        workDurationSecs: entry.workDurationSecs,
+    })), ((0, isDefined_utils_1.isDefinedNumber)(entry.restDurationSecs) && {
+        restDurationSecs: entry.restDurationSecs,
     })), ((0, isDefined_utils_1.isDefined)(entry.setNote) && { setNote: entry.setNote }));
     if (entry.type === "weight-reps") {
         return Object.assign(Object.assign({}, base), { type: "weight-reps", kg: (_a = (0, number_util_1.toNumber)(entry.kg)) !== null && _a !== void 0 ? _a : 0, rir: (0, isDefined_utils_1.isDefinedNumber)((0, number_util_1.toNumber)(entry.rir))
@@ -25,6 +27,15 @@ const refineRecordEntry = (entry) => {
             auxWeightKg: (0, number_util_1.toNumber)(entry.auxWeightKg),
         }));
     }
+    if (entry.type === "distance") {
+        const distanceKm = (_d = (0, number_util_1.toNumber)(entry.distanceKm)) !== null && _d !== void 0 ? _d : 0;
+        const durationSecs = (_e = (0, number_util_1.toNumber)(entry.durationSecs)) !== null && _e !== void 0 ? _e : 0;
+        // Calculate pace if both distance and duration are provided
+        const avgPaceSecsPerKm = distanceKm > 0 && durationSecs > 0
+            ? durationSecs / distanceKm
+            : undefined;
+        return Object.assign(Object.assign(Object.assign({}, base), { type: "distance", distanceKm, durationSecs: entry.durationSecs }), ((0, isDefined_utils_1.isDefinedNumber)(avgPaceSecsPerKm) && { avgPaceSecsPerKm }));
+    }
     throw new Error(`Unknown record type: ${entry.type}`);
 };
 exports.refineRecordEntry = refineRecordEntry;

package/dist/utils/scoring.utils.d.ts

@@ -17,16 +17,14 @@ type TScoreBreakdown = {
 type TParams = {
     record: TRefinedRecord;
     userProfile?: TUserProfile;
-    avgRestInBetweenDurationSecs?: number;
+    avgRestDurationSecs?: number;
     exerciseDefaultDifficultyMultiplier?: number;
+    isTimeIntervalModeEnabled?: boolean;
+    sessionSetCount?: number;
 };
 /**
  * Compute the training stress score for a given record.
- *
- * @param record - A refined workout set record
- * @param userProfile - Optional user demographics (age, gender, weight)
- * @param avgRestInBetweenDurationSecs - Average rest between sets in session
- * @returns An object with baseScore, applied boosts, penalties, and final score
+ * Uses improved load calculations with type-specific normalization and MET values for cardio.
  */
-export declare const computeScoreFromRecord: ({ exerciseDefaultDifficultyMultiplier, avgRestInBetweenDurationSecs, record, userProfile, }: TParams) => TScoreBreakdown;
+export declare const computeScoreFromRecord: ({ exerciseDefaultDifficultyMultiplier, avgRestDurationSecs, record, userProfile, isTimeIntervalModeEnabled, sessionSetCount, }: TParams) => TScoreBreakdown;
 export {};

package/dist/utils/scoring.utils.js

@@ -4,14 +4,10 @@ exports.computeScoreFromRecord = void 0;
 const time_util_1 = require("./time.util");
 /**
  * Compute the training stress score for a given record.
- *
- * @param record - A refined workout set record
- * @param userProfile - Optional user demographics (age, gender, weight)
- * @param avgRestInBetweenDurationSecs - Average rest between sets in session
- * @returns An object with baseScore, applied boosts, penalties, and final score
+ * Uses improved load calculations with type-specific normalization and MET values for cardio.
  */
-const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRestInBetweenDurationSecs, record, userProfile, }) => {
-    var _a, _b, _c, _d, _e;
+const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRestDurationSecs, record, userProfile, isTimeIntervalModeEnabled = false, sessionSetCount = 1, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     if (!record.isDone) {
         return {
             baseScore: 0,
@@ -20,85 +16,202 @@ const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRe
             finalScore: 0,
         };
     }
-    // Step 1: Compute load
-    let load = 0;
+    const userWeight = (_a = userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) !== null && _a !== void 0 ? _a : 70;
+    const plus = [];
+    const minus = [];
+    // Step 1: Compute type-specific load with normalization
+    let rawLoad = 0;
+    let normalizedLoad = 0;
     switch (record.type) {
-        case "weight-reps":
-            load = record.kg * record.reps;
+        case "weight-reps": {
+            rawLoad = record.kg * record.reps;
+            normalizedLoad = rawLoad; // Baseline - no scaling needed
             break;
+        }
         case "duration": {
-            const durationSecs = (0, time_util_1.mmssToSecs)((_a = record.durationSecs) !== null && _a !== void 0 ? _a : "00:00");
-            const auxWeight = (_b = record.auxWeightKg) !== null && _b !== void 0 ? _b : 0;
-            load = auxWeight > 0 ? auxWeight * durationSecs : durationSecs;
+            const durationSecs = (0, time_util_1.mmssToSecs)((_b = record.durationSecs) !== null && _b !== void 0 ? _b : "00:00");
+            const auxWeight = (_c = record.auxWeightKg) !== null && _c !== void 0 ? _c : 0;
+            if (auxWeight > 0) {
+                // Weighted duration exercise (e.g., weighted plank)
+                rawLoad = auxWeight * durationSecs;
+                normalizedLoad = rawLoad * 0.8; // Slightly less intense than pure weight training
+            }
+            else {
+                // Bodyweight duration exercise (e.g., plank, wall sit)
+                rawLoad = userWeight * (durationSecs / 60); // Per minute scaling
+                normalizedLoad = rawLoad * 1.2; // Duration exercises are metabolically demanding
+            }
             break;
         }
         case "reps-only": {
-            const reps = (_c = record.reps) !== null && _c !== void 0 ? _c : 0;
-            const auxWeight = (_d = record.auxWeightKg) !== null && _d !== void 0 ? _d : 0;
-            const baseWeight = auxWeight > 0 ? auxWeight : (_e = userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) !== null && _e !== void 0 ? _e : 0;
-            load = baseWeight * reps;
+            const reps = (_d = record.reps) !== null && _d !== void 0 ? _d : 0;
+            const auxWeight = (_e = record.auxWeightKg) !== null && _e !== void 0 ? _e : 0;
+            const effectiveWeight = auxWeight > 0 ? auxWeight : userWeight;
+            rawLoad = effectiveWeight * reps;
+            normalizedLoad = rawLoad * 0.7; // Bodyweight exercises slightly less intense than free weights
+            break;
+        }
+        case "distance": {
+            const distance = (_f = record.distanceKm) !== null && _f !== void 0 ? _f : 0;
+            const durationSecs = (0, time_util_1.mmssToSecs)((_g = record.durationSecs) !== null && _g !== void 0 ? _g : "00:00");
+            if (distance > 0 && durationSecs > 0) {
+                // Calculate speed and estimate MET value
+                const speedKmh = (distance * 3600) / durationSecs;
+                // MET estimation based on speed (conservative estimates)
+                let metValue = 3; // Walking baseline
+                if (speedKmh > 4)
+                    metValue = 4.5; // Brisk walking
+                if (speedKmh > 6)
+                    metValue = 7; // Light jogging
+                if (speedKmh > 8)
+                    metValue = 9; // Running
+                if (speedKmh > 12)
+                    metValue = 12; // Fast running
+                if (speedKmh > 16)
+                    metValue = 15; // Very fast running
+                // Calculate calories burned: MET × weight(kg) × hours
+                const caloriesBurned = metValue * userWeight * (durationSecs / 3600);
+                rawLoad = caloriesBurned;
+                normalizedLoad = caloriesBurned * 8; // Scale cardio to match resistance training
+            }
             break;
         }
     }
-    // Step 2: Compute effort
-    let effortFactor = 0;
+    // Step 2: Base score using log scale with minimum threshold
+    const base = Math.log10(1 + Math.max(10, normalizedLoad)); // Minimum 10 to avoid very low scores
+    let workingScore = base;
+    // Step 3: Effort multiplier (RPE/RIR)
+    let effortFactor = 5; // Default moderate effort if no RPE/RIR provided
     if (typeof record.rpe === "number") {
-        effortFactor = record.rpe;
+        effortFactor = Math.max(1, Math.min(10, record.rpe));
     }
     else if (typeof record.rir === "number") {
-        effortFactor = 10 - record.rir;
+        effortFactor = Math.max(1, Math.min(10, 10 - record.rir));
     }
-    // Step 3: Base score using log scale
-    const base = Math.log10(1 + Math.max(0, load));
-    const plus = [];
-    const minus = [];
-    let rawScore = base;
-    // Step 4: Effort Boost
-    // Clamp effort factor to [0,10] range to avoid invalid boosts
-    const boundedEffortFactor = Math.max(0, Math.min(effortFactor, 10));
-    const effortBoost = 1 + boundedEffortFactor * 0.05;
-    rawScore *= effortBoost;
-    plus.push({ effortBoost: parseFloat((effortBoost - 1).toFixed(10)) });
-    // Step 5: User Profile Scaling
-    let adjustment = 1;
-    if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.gender) === "female")
-        adjustment *= 1.1;
-    if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.age) && userProfile.age > 50)
-        adjustment *= 1.15;
+    const effortMultiplier = 0.7 + effortFactor * 0.06; // Range: 0.76 to 1.3
+    workingScore *= effortMultiplier;
+    plus.push({
+        effortMultiplier: parseFloat((effortMultiplier - 1).toFixed(3)),
+    });
+    // Step 4: Volume/Fatigue factor (later sets are harder)
+    if (sessionSetCount > 1) {
+        const fatigueMultiplier = 1 + Math.min(0.3, (sessionSetCount - 1) * 0.05);
+        workingScore *= fatigueMultiplier;
+        plus.push({ fatigueBonus: parseFloat((fatigueMultiplier - 1).toFixed(3)) });
+    }
+    // Step 5: Interval training adjustments
+    if (isTimeIntervalModeEnabled) {
+        let intervalMultiplier = 1.08; // Base 8% boost for interval training
+        if (record.workDurationSecs && record.restDurationSecs) {
+            const restRatio = record.restDurationSecs / record.workDurationSecs;
+            // Optimal rest ratios vary by exercise type
+            let optimalRestRatio = 2.0; // Default
+            switch (record.type) {
+                case "weight-reps":
+                    optimalRestRatio = 3.0; // Strength needs more rest
+                    break;
+                case "distance":
+                case "duration":
+                    optimalRestRatio = 1.0; // Cardio can handle shorter rest
+                    break;
+                case "reps-only":
+                    optimalRestRatio = 1.5; // Bodyweight middle ground
+                    break;
+            }
+            // Bonus for staying close to optimal ratio (within 50% deviation)
+            const deviation = Math.abs(restRatio - optimalRestRatio) / optimalRestRatio;
+            if (deviation <= 0.5) {
+                const ratioBonus = 0.05 * (1 - deviation * 2); // Up to 5% bonus
+                intervalMultiplier += ratioBonus;
+            }
+        }
+        workingScore *= intervalMultiplier;
+        plus.push({
+            intervalTraining: parseFloat((intervalMultiplier - 1).toFixed(3)),
+        });
+    }
+    // Step 6: User profile adjustments
+    let profileMultiplier = 1;
+    // Gender adjustment (women typically have less muscle mass)
+    if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.gender) === "female") {
+        profileMultiplier *= 1.12;
+    }
+    // Age adjustment (strength declines with age)
+    if (userProfile === null || userProfile === void 0 ? void 0 : userProfile.age) {
+        if (userProfile.age > 50)
+            profileMultiplier *= 1.1;
+        if (userProfile.age > 65)
+            profileMultiplier *= 1.15;
+    }
+    // Weight normalization (smaller people work harder relatively)
     if ((userProfile === null || userProfile === void 0 ? void 0 : userProfile.weightKg) && userProfile.weightKg > 0) {
-        const normalizedWeight = 70;
-        adjustment *= normalizedWeight / userProfile.weightKg;
+        const weightAdjustment = 70 / userProfile.weightKg;
+        // Cap adjustment to prevent extreme values
+        profileMultiplier *= Math.max(0.7, Math.min(1.4, weightAdjustment));
     }
-    if (adjustment !== 1) {
-        rawScore *= adjustment;
-        plus.push({ profileAdjustment: parseFloat((adjustment - 1).toFixed(10)) });
+    if (profileMultiplier !== 1) {
+        workingScore *= profileMultiplier;
+        plus.push({
+            profileAdjustment: parseFloat((profileMultiplier - 1).toFixed(3)),
+        });
     }
-    // Step 6: Rest Penalty
-    if (typeof record.restInBetweenDurationSecs === "number" &&
-        typeof avgRestInBetweenDurationSecs === "number") {
-        const restUsed = record.restInBetweenDurationSecs;
-        const grace = 5 + effortFactor * 2;
-        const cap = grace + 25;
-        const restOver = restUsed - avgRestInBetweenDurationSecs;
-        if (restOver > grace) {
-            const cappedExcess = Math.min(restOver, cap);
-            const penaltyRatio = (cappedExcess - grace) / (cap - grace); // 0–1
-            const restPenalty = parseFloat((penaltyRatio * 0.2 * rawScore).toFixed(10));
-            rawScore -= restPenalty;
-            minus.push({ restPenalty });
+    // Step 7: Rest efficiency penalty
+    if (typeof record.restDurationSecs === "number" &&
+        typeof avgRestDurationSecs === "number") {
+        const restUsed = record.restDurationSecs;
+        const baseGrace = 10; // Base grace period
+        const effortGrace = effortFactor * 3; // More grace for higher effort
+        const totalGrace = baseGrace + effortGrace;
+        const maxPenaltyThreshold = totalGrace + 60; // Cap penalty threshold
+        const excessRest = restUsed - avgRestDurationSecs;
+        if (excessRest > totalGrace) {
+            const penaltyExcess = Math.min(excessRest - totalGrace, maxPenaltyThreshold - totalGrace);
+            const penaltyRatio = penaltyExcess / (maxPenaltyThreshold - totalGrace);
+            const restPenalty = penaltyRatio * 0.15 * workingScore; // Up to 15% penalty
+            workingScore -= restPenalty;
+            minus.push({ excessRestPenalty: parseFloat(restPenalty.toFixed(3)) });
         }
     }
-    let finalScore = parseFloat(rawScore.toFixed(2));
-    // Adjusting exerciseDefaultDifficultyMultiplier
-    finalScore *= exerciseDefaultDifficultyMultiplier;
-    plus.push({
-        exerciseDefaultDifficultyMultiplier: parseFloat(exerciseDefaultDifficultyMultiplier.toFixed(5)),
-    });
+    // Step 8: Work duration adherence (for timed exercises in interval mode)
+    if (isTimeIntervalModeEnabled && record.workDurationSecs) {
+        let actualDuration = 0;
+        if (record.type === "duration") {
+            actualDuration = (0, time_util_1.mmssToSecs)((_h = record.durationSecs) !== null && _h !== void 0 ? _h : "00:00");
+        }
+        else if (record.type === "distance") {
+            actualDuration = (0, time_util_1.mmssToSecs)((_j = record.durationSecs) !== null && _j !== void 0 ? _j : "00:00");
+        }
+        if (actualDuration > 0) {
+            const durationDiff = Math.abs(actualDuration - record.workDurationSecs);
+            const tolerance = record.workDurationSecs * 0.2; // 20% tolerance
+            if (durationDiff > tolerance) {
+                const excessPercent = (durationDiff - tolerance) / record.workDurationSecs;
+                const timingPenalty = Math.min(0.1 * workingScore, excessPercent * 0.08 * workingScore);
+                workingScore -= timingPenalty;
+                minus.push({
+                    timingDeviationPenalty: parseFloat(timingPenalty.toFixed(3)),
+                });
+            }
+        }
+    }
+    // Step 9: Exercise difficulty multiplier
+    workingScore *= exerciseDefaultDifficultyMultiplier;
+    if (exerciseDefaultDifficultyMultiplier !== 1) {
+        plus.push({
+            exerciseDifficulty: parseFloat((exerciseDefaultDifficultyMultiplier - 1).toFixed(3)),
+        });
+    }
+    // Step 10: Final score normalization and capping
+    let finalScore = Math.max(0, workingScore);
+    // Scale to a more intuitive range (roughly 0-100 for typical exercises)
+    finalScore *= 10;
+    // Cap extreme scores to prevent runaway values
+    finalScore = Math.min(200, finalScore);
     return {
         baseScore: parseFloat(base.toFixed(2)),
         plus,
         minus,
-        finalScore,
+        finalScore: parseFloat(finalScore.toFixed(1)),
     };
 };
 exports.computeScoreFromRecord = computeScoreFromRecord;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dgpholdings/greatoak-shared",
-  "version": "1.1.35",
+  "version": "1.1.36",
   "description": "Shared TypeScript types and utilities for @dgpholdings projects",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",