fitness-progression-calculator 1.1.0 → 1.2.0

package/dist/calculator.d.ts

@@ -21,7 +21,6 @@ interface UserEquipmentSettings {
 }
 /**
  * Main function to calculate progression based on exercise data and program type
- * Now accepts optional userSettings for equipment-specific increments
  */
 export declare function calculateProgression(data: ExerciseData, programType: "STRENGTH" | "HYPERTROPHY", userSettings?: UserEquipmentSettings): ProgressionResult;
 /**

package/dist/calculator.js

@@ -1,5 +1,4 @@
 "use strict";
-// services/progressionCalculator.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateProgression = calculateProgression;
 exports.roundToClosestIncrement = roundToClosestIncrement;
@@ -19,13 +18,16 @@ const DEFAULT_EQUIPMENT_SETTINGS = {
     machineIncrement: 5.0,
     experienceLevel: "BEGINNER",
 };
+// Constants
+const STARTING_HYPERTROPHY_REPS = 10; // Rep count to cycle back to after reaching MAX_REPS
+// Helper functions
 function isSpecialBodyweightExercise(exerciseName) {
     return SPECIAL_BODYWEIGHT_EXERCISES.includes(exerciseName.toUpperCase());
 }
 /**
- * Gets user's preferred increment for the given equipment type
+ * Gets base increment for the given equipment type from user settings
  */
-function getPreferredIncrement(equipmentType, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
+function getBaseIncrement(equipmentType, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
     switch (equipmentType) {
         case "BARBELL":
             return (userSettings.barbellIncrement ||
@@ -40,238 +42,163 @@ function getPreferredIncrement(equipmentType, userSettings = DEFAULT_EQUIPMENT_S
                 DEFAULT_EQUIPMENT_SETTINGS.machineIncrement);
         case "BODYWEIGHT":
             return (userSettings.dumbbellIncrement ||
-                DEFAULT_EQUIPMENT_SETTINGS.dumbbellIncrement); // Use dumbbell increment for weighted bodyweight
+                DEFAULT_EQUIPMENT_SETTINGS.dumbbellIncrement);
         default:
-            return 2.5; // Fallback
+            return 2.5; // Default fallback
     }
 }
 /**
- * Gets equipment-specific increments from user settings
- */
-function getEquipmentIncrements(equipmentType, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
-    // Define standard increments available for each equipment type
-    const standardIncrements = {
-        BARBELL: [1.25, 2.5, 5.0, 10.0],
-        DUMBBELL: [1.0, 2.0, 2.5, 5.0],
-        CABLE: [2.0, 2.5, 5.0, 10.0],
-        MACHINE: [2.5, 5.0, 10.0],
-        BODYWEIGHT: [1.0, 2.5, 5.0], // For weighted bodyweight exercises
-    };
-    // Get user's preferred increment for this equipment type
-    const preferredIncrement = getPreferredIncrement(equipmentType, userSettings);
-    // Return equipment's standard increments with preferred increment first
-    return [
-        preferredIncrement,
-        ...standardIncrements[equipmentType].filter((inc) => inc !== preferredIncrement),
-    ];
-}
-/**
- * Finds the closest available increment to the desired raw increment
+ * Calculate the total volume for a given exercise configuration
  */
-function findClosestIncrement(rawIncrement, availableIncrements) {
-    // If rawIncrement is smaller than smallest available increment, return smallest
-    if (rawIncrement <= availableIncrements[0]) {
-        return availableIncrements[0];
-    }
-    // Find closest increment by minimizing absolute difference
-    return availableIncrements.reduce((prev, curr) => Math.abs(curr - rawIncrement) < Math.abs(prev - rawIncrement) ? curr : prev);
+function calculateVolume(sets, reps, weight) {
+    return sets * reps * weight;
 }
 /**
- * Determines the appropriate standard increment based on exercise type, weight and experience level
+ * Handle bodyweight exercises specially
  */
-function getStandardIncrement(currentWeight, equipmentType, isCompound, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
-    // Get available increments for this equipment type
-    const availableIncrements = getEquipmentIncrements(equipmentType, userSettings);
-    const sortedIncrements = [...availableIncrements].sort((a, b) => a - b);
-    const smallestIncrement = sortedIncrements[0] || 1.25;
-    // Base increment size on exercise type and current weight
-    let rawIncrement;
-    if (isCompound) {
-        // Compound movements (bench, squat, deadlift):
-        if (currentWeight < 40) {
-            rawIncrement = 5.0; // Under 40kg: 5kg increments
-        }
-        else if (currentWeight < 100) {
-            rawIncrement = 2.5; // 40-100kg: 2.5kg increments
-        }
-        else {
-            rawIncrement = 1.25; // Over 100kg: 1.25kg increments
-        }
-    }
-    else {
-        // Isolation movements (curls, lateral raises):
-        if (currentWeight < 15) {
-            rawIncrement = 2.5; // Under 15kg: 2.5kg increments
-        }
-        else {
-            rawIncrement = 1.25; // Over 15kg: 1.25kg increments
-        }
-    }
-    // Modify based on experience level
-    const experienceLevel = (userSettings === null || userSettings === void 0 ? void 0 : userSettings.experienceLevel) || "BEGINNER";
-    if (experienceLevel === "INTERMEDIATE" && currentWeight > 60) {
-        // Intermediate lifters progress slower at higher weights
-        rawIncrement = Math.max(smallestIncrement, rawIncrement * 0.5);
-    }
-    else if (experienceLevel === "ADVANCED") {
-        // Advanced lifters progress slower overall
-        rawIncrement = Math.max(smallestIncrement, rawIncrement * 0.5);
-    }
-    // Find the closest available increment
-    return findClosestIncrement(rawIncrement, availableIncrements);
-}
-/**
- * Gets weight increment based on difficulty rating, equipment, weight and experience level
- */
-function getWeightIncrement(currentWeight, equipment, isCompound, rating, userSettings) {
-    // Get the standard increment for this exercise/weight
-    const standardIncrement = getStandardIncrement(currentWeight, equipment, isCompound, userSettings);
-    // Modify based on rating
-    switch (rating) {
-        case 1: // Very Easy - double the increment
-            return standardIncrement * 2;
-        case 2: // Easy - standard increment
-        case 3: // Moderate - standard increment
-            return standardIncrement;
-        case 4: // Hard - no increase
-            return 0;
-        case 5: // Too Hard - decrease
-            return -standardIncrement;
-        default:
-            return standardIncrement;
-    }
-}
-function calculateBodyweightProgression(data) {
+function handleBodyweightExercise(data) {
     switch (data.rating) {
         case 1: // Very easy
             return {
-                newWeight: 0,
+                newWeight: data.weight,
                 newReps: Math.min(data.reps + 2, MAX_REPS),
             };
         case 2: // Easy
-            return {
-                newWeight: 0,
-                newReps: Math.min(data.reps + 1, MAX_REPS),
-            };
         case 3: // Moderate
             return {
-                newWeight: 0,
+                newWeight: data.weight,
                 newReps: Math.min(data.reps + 1, MAX_REPS),
             };
         case 4: // Hard
             return {
-                newWeight: 0,
+                newWeight: data.weight,
                 newReps: data.reps,
             };
         case 5: // Too hard
             return {
-                newWeight: 0,
+                newWeight: data.weight,
                 newReps: Math.max(1, data.reps - 2),
             };
         default:
             return {
-                newWeight: 0,
+                newWeight: data.weight,
                 newReps: data.reps,
             };
     }
 }
-function calculateStrengthProgression(data, userSettings) {
-    // Handle special bodyweight exercises differently
-    if (data.equipment_type === "BODYWEIGHT" &&
-        isSpecialBodyweightExercise(data.exercise_name)) {
-        return calculateBodyweightProgression(data);
-    }
-    const increment = getWeightIncrement(data.weight, data.equipment_type, data.is_compound, data.rating, userSettings);
-    // Apply the calculated increment
-    return {
-        newWeight: Math.max(0, data.weight + increment),
-        newReps: data.reps,
-    };
-}
-function calculateVolumeIncrease(data, type, userSettings) {
-    const increment = getWeightIncrement(data.weight, data.equipment_type, data.is_compound, Math.min(data.rating, 3), // Cap at 3 to always get a positive increment for comparison
-    userSettings);
-    const currentVolume = data.sets * data.reps * data.weight;
-    if (type === "weight") {
-        return data.sets * data.reps * (data.weight + increment) - currentVolume;
-    }
-    // Only calculate rep increase if we're not at max reps
-    if (data.reps >= MAX_REPS) {
-        return Number.POSITIVE_INFINITY; // Force weight increase by making rep increase unfavorable
-    }
-    return data.sets * (data.reps + 1) * data.weight - currentVolume;
-}
-function calculateHypertrophyProgression(data, userSettings) {
-    // Handle special bodyweight exercises differently
-    if (data.equipment_type === "BODYWEIGHT" &&
-        isSpecialBodyweightExercise(data.exercise_name)) {
-        return calculateBodyweightProgression(data);
-    }
-    const increment = getWeightIncrement(data.weight, data.equipment_type, data.is_compound, data.rating, userSettings);
-    // For compound movements (except special bodyweight exercises), prioritize weight increases
-    if (data.is_compound) {
-        return calculateStrengthProgression(data, userSettings);
-    }
-    // For isolation exercises, implement progressive overload based on rating
-    switch (data.rating) {
-        case 1: {
-            // Very easy
-            const newReps = data.reps >= MAX_REPS ? data.reps : data.reps + 1;
-            return {
-                newWeight: data.weight + increment,
-                newReps: newReps,
-            };
-        }
-        case 2: {
-            // Easy - increase either weight or reps (larger increase)
-            if (data.reps >= MAX_REPS) {
-                return { newWeight: data.weight + increment, newReps: data.reps };
-            }
-            const volumeIncreaseWeight = calculateVolumeIncrease(data, "weight", userSettings);
-            const volumeIncreaseReps = calculateVolumeIncrease(data, "reps", userSettings);
-            return volumeIncreaseWeight > volumeIncreaseReps
-                ? { newWeight: data.weight + increment, newReps: data.reps }
-                : { newWeight: data.weight, newReps: data.reps + 1 };
-        }
-        case 3: {
-            // Moderate - choose smallest increase between weight and reps
-            if (data.reps >= MAX_REPS) {
-                return { newWeight: data.weight + increment, newReps: data.reps };
-            }
-            const weightIncrease = calculateVolumeIncrease(data, "weight", userSettings);
-            const repIncrease = calculateVolumeIncrease(data, "reps", userSettings);
-            return weightIncrease < repIncrease
-                ? { newWeight: data.weight + increment, newReps: data.reps }
-                : { newWeight: data.weight, newReps: data.reps + 1 };
-        }
+/**
+ * Calculate weight change based on rating
+ */
+function getWeightChangeForRating(rating, baseIncrement) {
+    switch (rating) {
+        case 1: // Very easy
+            return baseIncrement * 3;
+        case 2: // Easy
+            return baseIncrement * 2;
+        case 3: // Moderate
+            return baseIncrement;
         case 4: // Hard
-            return { newWeight: data.weight, newReps: data.reps };
+            return 0;
         case 5: // Too hard
-            return {
-                newWeight: Math.max(0, data.weight + increment),
-                newReps: data.reps,
-            };
+            return -baseIncrement;
         default:
-            return { newWeight: data.weight, newReps: data.reps };
+            return 0;
     }
 }
 /**
  * Main function to calculate progression based on exercise data and program type
- * Now accepts optional userSettings for equipment-specific increments
  */
-function calculateProgression(data, programType, userSettings) {
+function calculateProgression(data, programType, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
+    console.log(`Calculate progression for ${data.exercise_name}:`, {
+        currentWeight: data.weight,
+        currentReps: data.reps,
+        rating: data.rating,
+        equipmentType: data.equipment_type,
+        programType,
+    });
+    // Special handling for bodyweight exercises
+    if (data.equipment_type === "BODYWEIGHT" &&
+        isSpecialBodyweightExercise(data.exercise_name)) {
+        return handleBodyweightExercise(data);
+    }
+    // Get the base increment for this equipment type
+    const baseIncrement = getBaseIncrement(data.equipment_type, userSettings);
+    console.log(`Using ${data.equipment_type} increment: ${baseIncrement}kg`);
+    // Calculate weight change based on rating
+    const weightChange = getWeightChangeForRating(data.rating, baseIncrement);
+    // For strength programs, focus on weight increases
     if (programType === "STRENGTH") {
-        return calculateStrengthProgression(data, userSettings);
+        return {
+            newWeight: Math.max(0, data.weight + weightChange),
+            newReps: data.reps,
+        };
     }
-    return calculateHypertrophyProgression(data, userSettings);
+    // HYPERTROPHY program logic
+    // For ratings 4 (Hard) and 5 (Too Hard), no rep increase, only potential weight decrease
+    if (data.rating >= 4) {
+        return {
+            newWeight: Math.max(0, data.weight + weightChange),
+            newReps: data.reps,
+        };
+    }
+    // If we've reached max reps, cycle back to starting reps with increased weight
+    if (data.reps >= MAX_REPS) {
+        // Calculate how much weight to increase to maintain volume
+        // Current volume: sets * maxReps * currentWeight
+        // New volume: sets * startingReps * newWeight
+        // So, newWeight = currentWeight * (maxReps / startingReps)
+        // Ensure the weight increases by at least the rating-based increment
+        const volumeBasedIncrement = data.weight * (MAX_REPS / STARTING_HYPERTROPHY_REPS) - data.weight;
+        const actualIncrement = Math.max(weightChange, volumeBasedIncrement);
+        return {
+            newWeight: Math.max(0, data.weight + actualIncrement),
+            newReps: STARTING_HYPERTROPHY_REPS,
+        };
+    }
+    // For ratings 1-3 with non-maxed reps, compare volume increases
+    // Option 1: Increase weight
+    const newWeight = Math.max(0, data.weight + weightChange);
+    const volumeWithWeightIncrease = calculateVolume(data.sets, data.reps, newWeight);
+    // Option 2: Increase reps
+    const newReps = data.reps + 1;
+    const volumeWithRepIncrease = calculateVolume(data.sets, newReps, data.weight);
+    // Calculate volume change for each option
+    const currentVolume = calculateVolume(data.sets, data.reps, data.weight);
+    const volumeChangeWithWeight = volumeWithWeightIncrease - currentVolume;
+    const volumeChangeWithReps = volumeWithRepIncrease - currentVolume;
+    console.log("Volume comparison:", {
+        currentVolume,
+        volumeWithWeightIncrease,
+        volumeWithRepIncrease,
+        volumeChangeWithWeight,
+        volumeChangeWithReps,
+    });
+    // For very easy (rating 1), always increase both weight and reps if compound
+    if (data.rating === 1 && data.is_compound) {
+        return {
+            newWeight: newWeight,
+            newReps: Math.min(newReps, MAX_REPS),
+        };
+    }
+    // For other cases, choose the option with the smaller volume increase
+    // This helps make sure progression is steady and not too aggressive
+    if (volumeChangeWithWeight <= volumeChangeWithReps) {
+        return {
+            newWeight: newWeight,
+            newReps: data.reps,
+        };
+    }
+    return {
+        newWeight: data.weight,
+        newReps: newReps,
+    };
 }
 /**
  * Helper function to round weight to closest available increment
  * Useful for client-side adjustments
  */
-function roundToClosestIncrement(weight, equipmentType, userSettings) {
-    const availableIncrements = getEquipmentIncrements(equipmentType, userSettings);
-    const preferredIncrement = availableIncrements[0];
-    // Round to nearest multiple of preferred increment
-    return Math.round(weight / preferredIncrement) * preferredIncrement;
+function roundToClosestIncrement(weight, equipmentType, userSettings = DEFAULT_EQUIPMENT_SETTINGS) {
+    const baseIncrement = getBaseIncrement(equipmentType, userSettings);
+    // Round to nearest multiple of baseIncrement
+    return Math.round(weight / baseIncrement) * baseIncrement;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "fitness-progression-calculator",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "Workout progression calculator for fitness applications",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -10,8 +10,12 @@
 		"build": "tsc",
 		"prepare": "npm run build"
 	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/VictorNorm/fitness-progression-calculator.git"
+	},
 	"keywords": ["fitness", "workout", "progression"],
-	"author": "Your Name",
+	"author": "Victor Norman",
 	"license": "MIT",
 	"files": ["dist/**/*"],
 	"devDependencies": {