@dgpholdings/greatoak-shared 1.1.22 → 1.1.24

package/dist/types/TApiExercise.d.ts

@@ -39,6 +39,7 @@ export type TExercise = {
     secondaryMuscles: TBodyPartKeys;
     trainingTypes: TTrainingType[];
     avgSetDurationInSecs?: number;
+    difficultyScoreMultiplier: number;
     difficultyLevel: number;
     hypertrophyLevel: number;
     strengthGainLevel: number;

package/dist/types/TApiExerciseRecord.d.ts

@@ -43,6 +43,7 @@ export type TApiExerciseRecordUpdateReq = {
         config: TRecordConfig;
         exerciseNote: string;
         restTimeSecs?: number;
+        difficultyScoreMultiplier: number;
         record: TRecord[];
     }[];
 };

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

@@ -4,16 +4,29 @@ type TUserProfile = {
     gender?: "male" | "female" | "non-binary" | "unspecified";
     weightKg?: number;
 };
+type TScoreBreakdown = {
+    baseScore: number;
+    plus: {
+        [reason: string]: number;
+    }[];
+    minus: {
+        [reason: string]: number;
+    }[];
+    finalScore: number;
+};
+type TParams = {
+    record: TRefinedRecord;
+    userProfile?: TUserProfile;
+    avgRestInBetweenDurationSecs?: number;
+    exerciseDefaultDifficultyMultiplier?: number;
+};
 /**
- * The score represents the training stimulus or workload stress generated by a specific set of exercise inputs.
- * in short: Training Stress Score (TSS)
- * We can use the score for:
-    1.Tracking session intensity or set difficulty over time
-    2. Deciding muscle recovery readiness
-    3. Creating training summaries, like:
-        - Daily workload
-        - Volume comparisons
-        - Weekly fatigue trends
+ * 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
  */
-export declare const computeScoreFromRecord: (record: TRefinedRecord, userProfile?: TUserProfile) => number;
+export declare const computeScoreFromRecord: ({ exerciseDefaultDifficultyMultiplier, avgRestInBetweenDurationSecs, record, userProfile, }: TParams) => TScoreBreakdown;
 export {};

package/dist/utils/scoring.utils.js

@@ -3,60 +3,63 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeScoreFromRecord = void 0;
 const time_util_1 = require("./time.util");
 /**
- * The score represents the training stimulus or workload stress generated by a specific set of exercise inputs.
- * in short: Training Stress Score (TSS)
- * We can use the score for:
-    1.Tracking session intensity or set difficulty over time
-    2. Deciding muscle recovery readiness
-    3. Creating training summaries, like:
-        - Daily workload
-        - Volume comparisons
-        - Weekly fatigue trends
+ * 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
  */
-const computeScoreFromRecord = (record, userProfile) => {
-    var _a, _b, _c, _d, _e, _f;
-    if (!record.isDone)
-        return 0;
-    // Determine load and effortFactor from record based on type
-    let load = 0;
-    let effortFactor = 0;
-    const rpe = (_a = record.rpe) !== null && _a !== void 0 ? _a : undefined;
-    const rir = (_b = record.rir) !== null && _b !== void 0 ? _b : undefined;
-    // Step 1: Determine effort factor
-    if (typeof rpe === "number") {
-        effortFactor = rpe;
+const computeScoreFromRecord = ({ exerciseDefaultDifficultyMultiplier = 1, avgRestInBetweenDurationSecs, record, userProfile, }) => {
+    var _a, _b, _c, _d, _e;
+    if (!record.isDone) {
+        return {
+            baseScore: 0,
+            plus: [],
+            minus: [],
+            finalScore: 0,
+        };
     }
-    else if (typeof rir === "number") {
-        effortFactor = 10 - rir; // lower RIR means more effort
-    }
-    // Step 2: Determine load
+    // Step 1: Compute load
+    let load = 0;
     switch (record.type) {
-        case "weight-reps": {
+        case "weight-reps":
             load = record.kg * record.reps;
             break;
-        }
         case "duration": {
-            const durationSecs = (0, time_util_1.mmssToSecs)((_c = record.durationSecs) !== null && _c !== void 0 ? _c : "00:00");
-            const auxWeight = (_d = record.auxWeightKg) !== null && _d !== void 0 ? _d : 0;
+            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;
             break;
         }
         case "reps-only": {
-            const reps = (_e = record.reps) !== null && _e !== void 0 ? _e : 0;
-            const auxWeight = (_f = record.auxWeightKg) !== null && _f !== void 0 ? _f : 0;
-            load = auxWeight > 0 ? auxWeight * reps : reps;
+            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;
             break;
         }
-        default:
-            return 0;
     }
-    return computeFinalScore(load, effortFactor, userProfile);
-};
-exports.computeScoreFromRecord = computeScoreFromRecord;
-const computeFinalScore = (load, effortFactor, userProfile) => {
+    // Step 2: Compute effort
+    let effortFactor = 0;
+    if (typeof record.rpe === "number") {
+        effortFactor = record.rpe;
+    }
+    else if (typeof record.rir === "number") {
+        effortFactor = 10 - record.rir;
+    }
+    // Step 3: Base score using log scale
     const base = Math.log10(1 + Math.max(0, load));
-    const effortBoost = 1 + Math.min(effortFactor, 10) * 0.05;
-    // Optional scaling
+    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;
@@ -66,5 +69,36 @@ const computeFinalScore = (load, effortFactor, userProfile) => {
         const normalizedWeight = 70;
         adjustment *= normalizedWeight / userProfile.weightKg;
     }
-    return base * effortBoost * adjustment;
+    if (adjustment !== 1) {
+        rawScore *= adjustment;
+        plus.push({ profileAdjustment: parseFloat((adjustment - 1).toFixed(10)) });
+    }
+    // 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 });
+        }
+    }
+    let finalScore = parseFloat(rawScore.toFixed(2));
+    // Adjusting exerciseDefaultDifficultyMultiplier
+    finalScore *= exerciseDefaultDifficultyMultiplier;
+    plus.push({
+        exerciseDefaultDifficultyMultiplier: parseFloat(exerciseDefaultDifficultyMultiplier.toFixed(5)),
+    });
+    return {
+        baseScore: parseFloat(base.toFixed(2)),
+        plus,
+        minus,
+        finalScore,
+    };
 };
+exports.computeScoreFromRecord = computeScoreFromRecord;

package/package.json

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