@dgpholdings/greatoak-shared 1.2.86 → 1.2.88

package/dist/utils/scoringWorkout/types.d.ts

@@ -31,32 +31,49 @@ export type TMuscleFatigueResult = Record<string, TMuscleFatigueEntry>;
 /**
  * Quality score breakdown — lets the UI show users WHY they got their score.
  * Each sub-score is 0–100.
+ *
+ * Note: restDiscipline is 0 (and restDisciplineActive is false on IScoreResult)
+ * when the user did not log rest timing data. Check restDisciplineActive before
+ * rendering the rest discipline bar in the UI.
  */
 export interface IQualityBreakdown {
-    /** Did the user complete all sets? */
+    /** Did the user complete all planned sets? */
     completion: number;
     /** Were sets consistent in output (or intentionally progressive)? */
     consistency: number;
-    /** Was effort in the productive RPE/RIR zone? */
+    /**
+     * Was effort in the productive RPE/RIR zone?
+     * RPE and RIR are optional — users may choose not to log them.
+     * When absent, this sub-score is EFFORT_NO_DATA_SCORE (50) — neutral,
+     * never penalising omission.
+     */
     effortAdequacy: number;
-    /** Were rest periods within the exercise's optimal range? */
+    /**
+     * Were rest periods within the exercise's optimal range?
+     * 0 when no rest data was logged (restDisciplineActive = false).
+     */
     restDiscipline: number;
 }
 /**
- * The final result returned by calculateExerciseScore.
+ * The final result returned by calculateExerciseScoreV2.
+ *
+ * Option A flat shape — one exercise produces one score and one breakdown.
+ * Goal-specific adaptation and progression logic live in the gate system
+ * and quick plan generator, not in the per-exercise score.
  *
- * - muscleScores:    per-muscle fatigue map (keyed by EBodyParts key, value 0–100)
- * - calorieBurn:     estimated kilocalories burned (gross, including EPOC)
- * - scoresByGoal:    branched scores for each of the user's selected goals
+ * Fields:
+ *   score                — 0–100 quality of execution
+ *   qualityBreakdown     — per-component breakdown (completion/consistency/effort/rest)
+ *   muscleScores         — per-muscle fatigue (keyed by EBodyParts key, 0–100)
+ *   calorieBurn          — estimated kcal (placeholder: 0 until Phase 3)
+ *   restDisciplineActive — false when no rest data logged; use to gate UI rendering
  */
-export interface IScoreByGoal {
+export interface IScoreResult {
     score: number;
     qualityBreakdown: IQualityBreakdown;
-}
-export interface IScoreResult {
     muscleScores: Record<string, number>;
     calorieBurn: number;
-    scoresByGoal: Partial<Record<TAiFitnessGoal, IScoreByGoal>>;
+    restDisciplineActive: boolean;
 }
 export type TTrainingAgeBracket = "beginner" | "intermediate" | "advanced";
 /**
@@ -85,7 +102,10 @@ export interface IParsedSet {
     type: TRecord["type"];
     /** Active work duration for this set in seconds (estimated or measured) */
     activeDurationSecs: number;
-    /** Rest duration after this set in seconds (validated or fallback) */
+    /**
+     * Rest duration after this set in seconds (validated or fallback).
+     * null = last set in the exercise, or timing data was not logged.
+     */
     restDurationSecs: number | null;
     /**
      * Effort fraction: 0.0 (no effort) to 1.0 (max effort).
@@ -100,13 +120,13 @@ export interface IParsedSet {
     auxWeightKg?: number;
     /** duration: hold time in seconds */
     durationSecs?: number;
-    /** cardio-machine: speed */
+    /** cardio-machine: speed in km/h */
     speed?: number;
     /** cardio-machine: incline percentage (Treadmill) */
     inclinePercentage?: number;
     /** cardio-machine: resistance level (Elliptical, Cycling) */
     resistanceLevel?: number;
-    /** cardio-machine / cardio-free: distance (km) */
+    /** cardio-machine / cardio-free: distance in km */
     distance?: number;
     /** cardio-free / cardio-machine: session duration in seconds */
     cardioDurationSecs?: number;

package/package.json

@@ -1,31 +1,31 @@
-{
-	"name": "@dgpholdings/greatoak-shared",
-	"version": "1.2.86",
-	"description": "Shared TypeScript types and utilities for @dgpholdings projects",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"files": [
-		"dist/**/*"
-	],
-	"scripts": {
-		"build": "tsc",
-		"pub": "npm run test && npm run build && npm version patch && npm publish",
-		"format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
-		"format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,json,md}\"",
-		"test": "vitest run src",
-		"test:watch": "vitest src"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://gitlab.com/greatoak/shared.git"
-	},
-	"author": "Siddhartha Chowdhury",
-	"license": "MIT",
-	"devDependencies": {
-		"typescript": "^5.8.2",
-		"vitest": "^4.1.3"
-	},
-	"dependencies": {
-		"react-native-uuid": "^2.0.3"
-	}
-}
+{
+	"name": "@dgpholdings/greatoak-shared",
+	"version": "1.2.88",
+	"description": "Shared TypeScript types and utilities for @dgpholdings projects",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist/**/*"
+	],
+	"scripts": {
+		"build": "tsc",
+		"pub": "npm run test && npm run build && npm version patch && npm publish",
+		"format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
+		"format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,json,md}\"",
+		"test": "vitest run src",
+		"test:watch": "vitest src"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://gitlab.com/greatoak/shared.git"
+	},
+	"author": "Siddhartha Chowdhury",
+	"license": "MIT",
+	"devDependencies": {
+		"typescript": "^5.8.2",
+		"vitest": "^4.1.3"
+	},
+	"dependencies": {
+		"react-native-uuid": "^2.0.3"
+	}
+}

package/dist/utils/exerciseRecord/__mocks__/exercises.mock.d.ts

@@ -1,30 +0,0 @@
-import { TExercise } from "../../../types";
-/**
- * MOCK EXERCISE: Weight-Reps
- * Simulates a standard compound lift (e.g., Barbell Squat).
- */
-export declare const mockExerciseWeightReps: TExercise;
-/**
- * MOCK EXERCISE: Reps-Only
- * Simulates a bodyweight movement (e.g., Push-up).
- */
-export declare const mockExerciseRepsOnly: TExercise;
-/**
- * MOCK EXERCISE: Duration
- * Simulates an isometric hold (e.g., Plank).
- */
-export declare const mockExerciseDuration: TExercise;
-/**
- * MOCK EXERCISE: Cardio-Machine
- * Simulates a machine cardio session (e.g., Treadmill).
- */
-export declare const mockExerciseCardioMachine: TExercise;
-/**
- * MOCK EXERCISE: Cardio-Free
- * Simulates an outdoor/untracked cardio session (e.g., Outdoor Run).
- */
-export declare const mockExerciseCardioFree: TExercise;
-/**
- * Helper dictionary containing all mock exercises mapped by their ID.
- */
-export declare const mockExercisesDictionary: Record<string, TExercise>;

package/dist/utils/exerciseRecord/__mocks__/exercises.mock.js

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockExercisesDictionary = exports.mockExerciseCardioFree = exports.mockExerciseCardioMachine = exports.mockExerciseDuration = exports.mockExerciseRepsOnly = exports.mockExerciseWeightReps = void 0;
-/**
- * MOCK EXERCISE: Weight-Reps
- * Simulates a standard compound lift (e.g., Barbell Squat).
- */
-exports.mockExerciseWeightReps = {
-    exerciseId: "mock-exercise-weight-reps-123",
-    name: "Generic Barbell Squat",
-    bodyPart: ["Legs"],
-    recordType: "weight-reps",
-    primaryMuscles: ["quadriceps"],
-    secondaryMuscles: ["glutes-maximus"],
-    trainingTypes: ["weight"],
-    difficultyLevel: 2,
-    hypertrophyLevel: 4,
-    strengthGainLevel: 4,
-    flexibilityLevel: 1,
-    calorieBurnLevel: 3,
-    stabilityLevel: 2,
-    enduranceLevel: 1,
-    metabolicData: {
-        baseMET: 6.0,
-        metRange: [4.0, 8.0],
-        compoundMultiplier: 1.5,
-        muscleGroupFactor: 2.0,
-        intensityScaling: "exponential",
-        epocFactor: 0.15,
-    },
-    timingGuardrails: {
-        type: "weight-reps",
-        stressRestBonus: 5,
-        fatigueMultiplier: 1.2,
-        setupTypicalSecs: 10,
-        restPeriods: {
-            minimum: 60,
-            typical: 120,
-            maximum: 300,
-            optimalRange: [90, 180],
-        },
-        singleRep: {
-            min: 2.0,
-            max: 5.0,
-            typical: 3.5,
-        },
-    },
-    youtubeVideoUrl: ["https://youtube.com/watch?v=mock1"],
-    modelVideoUrl: "https://example.com/mock-video.mp4",
-    thumbnailUrl: "https://example.com/mock-thumb.png",
-    instructionsHtml: "<ul><li>Mock instruction 1</li></ul>",
-    importantTipsHtml: "<ul><li>Mock tip 1</li></ul>",
-    popularityIndex: 90,
-};
-/**
- * MOCK EXERCISE: Reps-Only
- * Simulates a bodyweight movement (e.g., Push-up).
- */
-exports.mockExerciseRepsOnly = Object.assign(Object.assign({}, exports.mockExerciseWeightReps), { exerciseId: "mock-exercise-reps-only-456", name: "Generic Push-Up", bodyPart: ["Chest", "Core"], recordType: "reps-only", primaryMuscles: ["pectoralis-major"], secondaryMuscles: ["tricep-brachii-lateral", "abs-lower"], trainingTypes: ["body-weight"], timingGuardrails: {
-        type: "reps-only",
-        stressRestBonus: 2,
-        fatigueMultiplier: 1.05,
-        setupTypicalSecs: 5,
-        restPeriods: {
-            minimum: 30,
-            typical: 60,
-            maximum: 180,
-            optimalRange: [45, 90],
-        },
-        singleRep: {
-            min: 1.0,
-            max: 3.0,
-            typical: 1.8,
-        },
-    } });
-/**
- * MOCK EXERCISE: Duration
- * Simulates an isometric hold (e.g., Plank).
- */
-exports.mockExerciseDuration = Object.assign(Object.assign({}, exports.mockExerciseWeightReps), { exerciseId: "mock-exercise-duration-789", name: "Generic Forearm Plank", bodyPart: ["Core"], recordType: "duration", primaryMuscles: ["abs-lower", "abs-upper"], secondaryMuscles: ["lower-back"], trainingTypes: ["body-weight", "isometric"], timingGuardrails: {
-        type: "duration",
-        stressRestBonus: 3,
-        fatigueMultiplier: 1.1,
-        setupTypicalSecs: 5,
-        restPeriods: {
-            minimum: 30,
-            typical: 60,
-            maximum: 120,
-            optimalRange: [45, 60],
-        },
-        setDuration: {
-            min: 15,
-            max: 300,
-            typical: 60,
-        },
-    } });
-/**
- * MOCK EXERCISE: Cardio-Machine
- * Simulates a machine cardio session (e.g., Treadmill).
- */
-exports.mockExerciseCardioMachine = Object.assign(Object.assign({}, exports.mockExerciseWeightReps), { exerciseId: "mock-exercise-cardio-machine-101", name: "Generic Treadmill Run", bodyPart: ["Legs"], recordType: "cardio-machine", primaryMuscles: ["quadriceps", "hamstrings", "calves"], secondaryMuscles: ["glutes-maximus"], trainingTypes: ["cardio"], timingGuardrails: {
-        type: "cardio-machine",
-        stressRestBonus: 0,
-        fatigueMultiplier: 1.0,
-        setupTypicalSecs: 15,
-        restPeriods: {
-            minimum: 0,
-            typical: 0,
-            maximum: 300,
-            optimalRange: [0, 60],
-        },
-    } });
-/**
- * MOCK EXERCISE: Cardio-Free
- * Simulates an outdoor/untracked cardio session (e.g., Outdoor Run).
- */
-exports.mockExerciseCardioFree = Object.assign(Object.assign({}, exports.mockExerciseWeightReps), { exerciseId: "mock-exercise-cardio-free-202", name: "Generic Outdoor Jog", bodyPart: ["Legs"], recordType: "cardio-free", primaryMuscles: ["quadriceps", "hamstrings", "calves"], secondaryMuscles: ["glutes-maximus"], trainingTypes: ["cardio"], timingGuardrails: {
-        type: "cardio-free",
-        stressRestBonus: 0,
-        fatigueMultiplier: 1.0,
-        setupTypicalSecs: 0,
-        restPeriods: {
-            minimum: 0,
-            typical: 0,
-            maximum: 300,
-            optimalRange: [0, 0],
-        },
-    } });
-/**
- * Helper dictionary containing all mock exercises mapped by their ID.
- */
-exports.mockExercisesDictionary = {
-    [exports.mockExerciseWeightReps.exerciseId]: exports.mockExerciseWeightReps,
-    [exports.mockExerciseRepsOnly.exerciseId]: exports.mockExerciseRepsOnly,
-    [exports.mockExerciseDuration.exerciseId]: exports.mockExerciseDuration,
-    [exports.mockExerciseCardioMachine.exerciseId]: exports.mockExerciseCardioMachine,
-    [exports.mockExerciseCardioFree.exerciseId]: exports.mockExerciseCardioFree,
-};

package/dist/utils/scaleProPlan.util.d.ts

@@ -1,9 +0,0 @@
-import { TProPlan, TUserMetric, TExercise } from "../types";
-/**
- * Calculates the BMI (Body Mass Index).
- */
-export declare const calculateBMI: (weightKg: number, heightCm: number) => number;
-/**
- * The Adoption Engine: Safely scales a Master Pro Plan to fit an individual user's body type.
- */
-export declare const scaleProPlan: (masterPlan: TProPlan, userMetric: TUserMetric, exercisesDictionary: Record<string, TExercise>) => TProPlan;

package/dist/utils/scaleProPlan.util.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaleProPlan = exports.calculateBMI = void 0;
-const NO_THRESHOLD = Infinity;
-/**
- * Calculates the BMI (Body Mass Index).
- */
-const calculateBMI = (weightKg, heightCm) => {
-    if (!weightKg || !heightCm || heightCm <= 0)
-        return 0;
-    const heightM = heightCm / 100;
-    return Number((weightKg / (heightM * heightM)).toFixed(1));
-};
-exports.calculateBMI = calculateBMI;
-/**
- * Rounds a calculated weight load to the nearest sensible gym increment (e.g. 2.5kg).
- */
-const roundToNearest = (val, increment) => Math.round(val / increment) * increment;
-/**
- * Calculates effective BMI threshold based on the user's fitness activity level.
- * Active users carry more muscle, so their BMI threshold for bodyweight safety triggers is raised.
- */
-const getAdjustedBMIThreshold = (baseThreshold, activityLevel) => {
-    if (!baseThreshold)
-        return NO_THRESHOLD;
-    switch (activityLevel) {
-        case "very-active":
-            return baseThreshold + 5; // e.g. Obese trigger moves from 30 to 35
-        case "moderately-active":
-            return baseThreshold + 3; // e.g. Obese trigger moves from 30 to 33
-        case "lightly-active":
-            return baseThreshold + 1;
-        case "sedentary":
-        default:
-            return baseThreshold; // No adjustment
-    }
-};
-/**
- * Modifies an individual record based on fallback logic (when no regression exercise exists, or for softer triggers).
- * Reduces volume or duration by roughly 30%.
- */
-const applyFallbackScalingToRecord = (record) => {
-    const scaledRecord = Object.assign({}, record);
-    const SCALE_FACTOR = 0.7;
-    // Scale reps
-    if (scaledRecord.type === "reps-only" || scaledRecord.type === "weight-reps") {
-        const currentReps = parseInt(scaledRecord.reps, 10);
-        if (!isNaN(currentReps) && currentReps > 0) {
-            scaledRecord.reps = Math.max(1, Math.round(currentReps * SCALE_FACTOR)).toString();
-        }
-    }
-    // Scale duration for all time-based records
-    if (scaledRecord.type === "duration" ||
-        scaledRecord.type === "cardio-machine" ||
-        scaledRecord.type === "cardio-free") {
-        const [mm, ss] = scaledRecord.durationMmSs.split(":").map(Number);
-        if (!isNaN(mm) && !isNaN(ss)) {
-            const totalSecs = mm * 60 + ss;
-            const newSecs = Math.max(5, Math.round(totalSecs * SCALE_FACTOR)); // minimum 5 seconds
-            const newMm = Math.floor(newSecs / 60).toString();
-            const newMmPadded = newMm.length < 2 ? "0" + newMm : newMm;
-            const newSs = (newSecs % 60).toString();
-            const newSsPadded = newSs.length < 2 ? "0" + newSs : newSs;
-            scaledRecord.durationMmSs = `${newMmPadded}:${newSsPadded}`;
-        }
-    }
-    return scaledRecord;
-};
-/**
- * The Adoption Engine: Safely scales a Master Pro Plan to fit an individual user's body type.
- */
-const scaleProPlan = (masterPlan, userMetric, exercisesDictionary) => {
-    // We don't mutate the original
-    const tailoredPlan = JSON.parse(JSON.stringify(masterPlan));
-    const { weightKg, heightCm, gender, fitnessLevel } = userMetric;
-    const bmi = weightKg && heightCm ? (0, exports.calculateBMI)(weightKg, heightCm) : 0;
-    tailoredPlan.days.forEach((day) => {
-        day.exercises = day.exercises.map((templateExercise) => {
-            const exerciseMeta = exercisesDictionary[templateExercise.exerciseId];
-            // If we can't find metadata, return as-is
-            if (!exerciseMeta)
-                return templateExercise;
-            let isModified = false;
-            let newExerciseId = templateExercise.exerciseId;
-            let newRecords = [...templateExercise.initialRecords];
-            // 1. Check Safety Triggers (BMI & Bodyweight Dependency)
-            if (bmi > 0 &&
-                (exerciseMeta.bodyweightDependency === "high" || exerciseMeta.bodyweightDependency === "medium") &&
-                exerciseMeta.bmiThresholds) {
-                const obeseTrigger = getAdjustedBMIThreshold(exerciseMeta.bmiThresholds.obeseTrigger, fitnessLevel);
-                const overweightTrigger = getAdjustedBMIThreshold(exerciseMeta.bmiThresholds.overweightTrigger, fitnessLevel);
-                if (bmi >= obeseTrigger) {
-                    // Tier 1: Hard swap to regression (if available) AND scale down volume
-                    newRecords = newRecords.map(applyFallbackScalingToRecord);
-                    isModified = true;
-                    if (exerciseMeta.regressionExerciseId && exercisesDictionary[exerciseMeta.regressionExerciseId]) {
-                        newExerciseId = exerciseMeta.regressionExerciseId;
-                    }
-                }
-                else if (bmi >= overweightTrigger) {
-                    // Tier 2: Softer response. Keep the exercise, but scale down the volume/duration.
-                    newRecords = newRecords.map(applyFallbackScalingToRecord);
-                    isModified = true;
-                }
-            }
-            // 2. Check Load Multipliers
-            if (weightKg && exerciseMeta.weightMultiplier && newRecords.length > 0) {
-                const multiplier = gender === "male"
-                    ? exerciseMeta.weightMultiplier.male
-                    : gender === "female"
-                        ? exerciseMeta.weightMultiplier.female
-                        : exerciseMeta.weightMultiplier.default;
-                if (multiplier && multiplier > 0) {
-                    // Round to nearest 2.5kg to match real-world gym equipment
-                    const suggestedLoadKg = roundToNearest(weightKg * multiplier, 2.5);
-                    newRecords = newRecords.map((record) => {
-                        if (record.type === "weight-reps") {
-                            isModified = true;
-                            return Object.assign(Object.assign({}, record), { kg: suggestedLoadKg.toString() });
-                        }
-                        // Guard against applying load to a falsy "0" aux weight
-                        if (record.type === "reps-only" || record.type === "duration" || record.type === "cardio-free") {
-                            const currentAux = parseFloat(record.auxWeightKg || "0");
-                            if (!isNaN(currentAux) && currentAux > 0) {
-                                isModified = true;
-                                return Object.assign(Object.assign({}, record), { auxWeightKg: suggestedLoadKg.toString() });
-                            }
-                        }
-                        return record;
-                    });
-                }
-            }
-            // Return the tailored template exercise
-            return Object.assign(Object.assign({}, templateExercise), { exerciseId: newExerciseId, initialRecords: newRecords, isAutoScaled: isModified || undefined });
-        });
-    });
-    return tailoredPlan;
-};
-exports.scaleProPlan = scaleProPlan;

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

@@ -1,67 +0,0 @@
-/**
- * ============================================================================
- * FITFRIX EXERCISE SCORING SYSTEM — Pillar 1: Calorie Burn
- * ============================================================================
- *
- * Estimates energy expenditure (kcal) for an exercise using the MET system.
- *
- * Formula (per set):
- *   calories = effectiveMET × userWeightKg × (activeDurationSecs / 3600)
- *
- * Where effectiveMET is the exercise's baseMET adjusted for:
- *   - Effort level (RPE/RIR → scales within metRange)
- *   - Weight intensity (for weight-reps: how heavy relative to bodyweight)
- *   - Duration category (for duration: short/medium/long multiplier)
- *   - Speed (for cardio: interpolated from pace or speed range)
- *   - Compound multiplier (multi-joint exercises burn more)
- *
- * After summing all sets:
- *   - Rest calories are added (elevated MET during rest periods)
- *   - EPOC (afterburn) is added as a percentage of work calories
- *
- * References:
- *   - Ainsworth BE et al. "Compendium of Physical Activities" (2011)
- *   - Katch, McArdle & Katch, "Exercise Physiology" (8th ed.)
- */
-import type { IParsedSet, IUserContext } from "./types";
-interface IMetabolicData {
-    baseMET: number;
-    metRange: [number, number];
-    compoundMultiplier: number;
-    muscleGroupFactor: number;
-    intensityScaling: "linear" | "exponential" | "plateau";
-    epocFactor: number;
-    weightFactors?: {
-        lightWeight: number;
-        moderateWeight: number;
-        heavyWeight: number;
-    };
-    durationFactors?: {
-        shortDuration: number;
-        mediumDuration: number;
-        longDuration: number;
-    };
-    paceFactors?: Record<string, number>;
-    lightWeight?: number;
-    moderateWeight?: number;
-    heavyWeight?: number;
-    shortDuration?: number;
-    mediumDuration?: number;
-    longDuration?: number;
-}
-/**
- * Calculate total calorie burn for an exercise.
- *
- * @param sets           Parsed & validated sets (from parseRecords)
- * @param metabolicData  Exercise's metabolic configuration
- * @param user           Validated user context
- * @param difficultyLevel Exercise difficulty (0–4), used for bodyweight estimation
- * @returns              Total calories burned (kcal), rounded to 1 decimal
- *
- * @example
- * const calories = calculateCalories(parsedSets, exercise.metabolicData, userCtx, exercise.difficultyLevel);
- * // → 6.4 (for 3 light bench press sets)
- * // → 142.3 (for a 20-min treadmill run)
- */
-export declare function calculateCalories(sets: IParsedSet[], metabolicData: IMetabolicData, user: IUserContext, difficultyLevel: number, scoringSpecialHandling?: "plyometric" | "stretch-mobility" | "continuous-duration" | "loaded-carry"): number;
-export {};