hevy-shared 1.0.714 → 1.0.715

package/built/hevyTrainer.d.ts

@@ -5,6 +5,34 @@ export type HevyTrainerProgramEquipment = Extract<Equipment, 'barbell' | 'dumbbe
 export declare const hevyTrainerExerciseCategories: readonly ["compound", "isolation"];
 export declare const routineNames: readonly ["full_body_1", "full_body_2_a", "full_body_2_b", "full_body_3_a", "full_body_3_b", "full_body_3_c", "upper_1_a", "lower_1_a", "upper_1_b", "lower_1_b", "push_1", "pull_1", "legs_1", "upper_2", "lower_2", "push_2_a", "pull_2_a", "legs_2_a", "push_2_b", "pull_2_b", "legs_2_b"];
 export type exerciseId = string;
+export interface ExerciseSelectionCriteria {
+    exerciseCategory: HevyTrainerExerciseCategory;
+    equipments: HevyTrainerProgramEquipment[];
+    routineBarbellExerciseCount: number;
+    level: TrainingLevel;
+    goal: TrainingGoal;
+    muscleGroup: MuscleGroup;
+}
+export interface ExerciseSelectionContext {
+    programUsedExerciseIds?: Set<string>;
+    routineUsedExerciseIds?: Set<string>;
+    excludedExerciseIds?: Set<string>;
+}
+export interface ExerciseSelectionParams {
+    sortedExercises: Record<MuscleGroup, HevyTrainerLibraryExercise[]>;
+    criteria: ExerciseSelectionCriteria;
+    context: ExerciseSelectionContext;
+}
+export interface ProgramGenerationParams<T extends HevyTrainerLibraryExercise> {
+    trainerPreset: TrainerPreset;
+    selectedDays: WeeklyTrainingFrequency;
+    selectedGoal: TrainingGoal;
+    selectedLevel: TrainingLevel;
+    selectedEquipments: HevyTrainerProgramEquipment[];
+    exerciseStore: T[];
+    focusMuscle?: SimplifiedMuscleGroup;
+    excludedExerciseIds?: Set<string>;
+}
 export declare const frequencyMap: Record<WeeklyTrainingFrequency, string>;
 export declare const programSplits: Record<WeeklyTrainingFrequency, HevyTrainerRoutineName[]>;
 export type SetsPerGoal = {
@@ -84,6 +112,21 @@ export interface TrainerProgram {
     name: WeeklyTrainingFrequency;
     routines: TrainerProgramRoutine[];
 }
+/**
+ * Sorts exercises by priority for each muscle group based on the provided priorities
+ * and adds any remaining exercises from the store that weren't in the priorities.
+ *
+ * @param exercisePriorities - Object mapping muscle groups to arrays of exercise IDs in priority order
+ * @param exerciseStore - Array of all available exercises
+ * @returns Object mapping muscle groups to arrays of exercises sorted by priority
+ */
+export declare const getPrioritySortedExercises: <T extends HevyTrainerLibraryExercise>(exercisePriorities: ExercisePriorities, exerciseStore: T[]) => Record<MuscleGroup, T[]>;
+/**
+ * Selects the best exercise for a given prescription using a multi-pass strategy
+ */
+export declare const pickExerciseForPrescription: <T extends HevyTrainerLibraryExercise>(params: ExerciseSelectionParams & {
+    sortedExercises: Record<MuscleGroup, T[]>;
+}) => T | undefined;
 export type HevyTrainerLibraryExercise = Pick<LibraryExercise, 'id' | 'title' | 'priority' | 'muscle_group' | 'other_muscles' | 'exercise_type' | 'equipment_category' | 'category' | 'level' | 'goal'>;
 export interface ExercisePrescriptionError {
     type: 'exercise_not_found';
@@ -115,12 +158,7 @@ export interface TrainerProgramError {
     partialProgram?: TrainerProgram;
 }
 export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
-export declare const generateProgram: ({ trainerPreset, selectedDays, selectedGoal, selectedLevel, selectedEquipments, exerciseStore, focusMuscle, }: {
-    trainerPreset: TrainerPreset;
-    selectedDays: WeeklyTrainingFrequency;
-    selectedGoal: TrainingGoal;
-    selectedLevel: TrainingLevel;
-    selectedEquipments: HevyTrainerProgramEquipment[];
-    exerciseStore: HevyTrainerLibraryExercise[];
-    focusMuscle?: SimplifiedMuscleGroup;
-}) => TrainerProgramAttempt;
+/**
+ * Generates a complete training program based on the provided parameters
+ */
+export declare const generateProgram: <T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>) => TrainerProgramAttempt;

package/built/hevyTrainer.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateProgram = exports.programSplits = exports.frequencyMap = exports.routineNames = exports.hevyTrainerExerciseCategories = void 0;
+exports.generateProgram = exports.pickExerciseForPrescription = exports.getPrioritySortedExercises = exports.programSplits = exports.frequencyMap = exports.routineNames = exports.hevyTrainerExerciseCategories = void 0;
 const _1 = require(".");
+const MAX_BARBELL_EXERCISES_PER_ROUTINE = 2;
 exports.hevyTrainerExerciseCategories = ['compound', 'isolation'];
 exports.routineNames = [
     // Full body 1x
@@ -48,6 +49,24 @@ exports.programSplits = {
     5: ['push_1', 'pull_1', 'legs_1', 'upper_2', 'lower_2'],
     6: ['push_2_a', 'pull_2_a', 'legs_2_a', 'push_2_b', 'pull_2_b', 'legs_2_b'],
 };
+// Utility functions for better code organization
+const isEquipmentCompatible = (exercise, allowedEquipments) => {
+    return (allowedEquipments.includes(exercise.equipment_category) ||
+        exercise.equipment_category === 'none' ||
+        exercise.equipment_category === 'other');
+};
+const isBarbellLimitExceeded = (exercise, routineBarbellExerciseCount, allowedEquipments) => {
+    return (exercise.equipment_category === 'barbell' &&
+        routineBarbellExerciseCount >= MAX_BARBELL_EXERCISES_PER_ROUTINE &&
+        allowedEquipments.length > 1);
+};
+const isExerciseUsed = (exercise, context) => {
+    var _a, _b, _c;
+    return (((_a = context.programUsedExerciseIds) === null || _a === void 0 ? void 0 : _a.has(exercise.id)) ||
+        ((_b = context.routineUsedExerciseIds) === null || _b === void 0 ? void 0 : _b.has(exercise.id)) ||
+        ((_c = context.excludedExerciseIds) === null || _c === void 0 ? void 0 : _c.has(exercise.id)) ||
+        false);
+};
 const isolationExerciseAlternatives = {
     chest: ['B74A95BB', '392887AA', '39C99849'],
     triceps: ['6575F52D', 'CD6DC8E5'],
@@ -70,68 +89,145 @@ const isolationExerciseAlternatives = {
     neck: [],
     full_body: [],
 };
+/**
+ * Sorts exercises by priority for each muscle group based on the provided priorities
+ * and adds any remaining exercises from the store that weren't in the priorities.
+ *
+ * @param exercisePriorities - Object mapping muscle groups to arrays of exercise IDs in priority order
+ * @param exerciseStore - Array of all available exercises
+ * @returns Object mapping muscle groups to arrays of exercises sorted by priority
+ */
+const getPrioritySortedExercises = (exercisePriorities, exerciseStore) => {
+    // Have a map of muscle group to exercises sorted by exercise priority
+    const sortedExercises = Object.entries(exercisePriorities).reduce((acc, [muscleGroup, exercises]) => {
+        const foundExercises = exercises
+            .map((exercise) => exerciseStore.find((e) => e.id === exercise))
+            .filter((exercise) => exercise !== undefined);
+        // Debug: Log missing exercise IDs
+        const missingIds = exercises.filter((id) => !exerciseStore.some((e) => e.id === id));
+        if (missingIds.length > 0) {
+            console.log(`Missing the following exercises with IDs in the store for muscle group ${muscleGroup}:`, missingIds);
+        }
+        acc[muscleGroup] = foundExercises;
+        return acc;
+    }, {});
+    // Then add remaining exercises to the map
+    Object.keys(sortedExercises).forEach((muscleGroup) => {
+        const remainingExercises = exerciseStore
+            .filter((e) => e.muscle_group === muscleGroup &&
+            !sortedExercises[muscleGroup].includes(e))
+            .sort((a, b) => b.priority - a.priority);
+        sortedExercises[muscleGroup].push(...remainingExercises);
+    });
+    return sortedExercises;
+};
+exports.getPrioritySortedExercises = getPrioritySortedExercises;
 const getMuscleGroup = ({ muscleGroupPrescription, programFocusMuscleExerciseCount, focusMuscle, }) => {
     if (muscleGroupPrescription === 'focus_muscle') {
         if (!!focusMuscle) {
             const n = _1.simplifiedMuscleGroupToMuscleGroups[focusMuscle].length;
             return _1.simplifiedMuscleGroupToMuscleGroups[focusMuscle][programFocusMuscleExerciseCount % n];
         }
-        // User has not selected a focus muscle, so we skip this extra exercise for the focus muscle
+        // User has not selected a focus muscle, so we skip this extra exercise for the focus muscle in the program
         return undefined;
     }
     return muscleGroupPrescription;
 };
-const isExerciseMatch = ({ exercisePrescription, exercise, equipments, routineBarbellExerciseCount, level, goal, }) => {
+/**
+ * Checks if an exercise matches the given criteria for selection
+ */
+const isExerciseMatch = (exercise, criteria) => {
+    var _a, _b, _c, _d;
+    const categoryMatch = exercise.category === criteria.exerciseCategory ||
+        (exercise.category === 'assistance-compound' &&
+            criteria.exerciseCategory === 'compound');
+    const levelMatch = (_b = (_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(criteria.level)) !== null && _b !== void 0 ? _b : false;
+    const goalMatch = (_d = (_c = exercise.goal) === null || _c === void 0 ? void 0 : _c.includes(criteria.goal)) !== null && _d !== void 0 ? _d : false;
+    const equipmentMatch = isEquipmentCompatible(exercise, criteria.equipments);
+    const barbellLimitOk = !isBarbellLimitExceeded(exercise, criteria.routineBarbellExerciseCount, criteria.equipments);
+    return (categoryMatch && levelMatch && goalMatch && equipmentMatch && barbellLimitOk);
+};
+/**
+ * Checks if an exercise is a valid alternative isolation exercise
+ */
+const isAlternativeIsolationExerciseMatch = (exercise, criteria) => {
     var _a, _b;
-    return ((exercise.category === exercisePrescription.category ||
-        (exercise.category === 'assistance-compound' && // Airtable also has `assistance-compound` as another category
-            exercisePrescription.category === 'compound')) && // but we are not differentiating between them and using `compound` instead
-        ((_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(level)) &&
-        ((_b = exercise.goal) === null || _b === void 0 ? void 0 : _b.includes(goal)) &&
-        (equipments.includes(exercise.equipment_category) ||
-            exercise.equipment_category === 'none' ||
-            exercise.equipment_category === 'other') &&
-        // Up to 2 barbell exercises per routine, unless there is only one equipment category selected
-        (exercise.equipment_category !== 'barbell' ||
-            routineBarbellExerciseCount < 2 ||
-            equipments.length === 1));
+    const isIsolationCategory = criteria.exerciseCategory === 'isolation';
+    const isAlternativeExercise = isolationExerciseAlternatives[criteria.muscleGroup].includes(exercise.id);
+    const equipmentMatch = isEquipmentCompatible(exercise, criteria.equipments);
+    const levelMatch = (_b = (_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(criteria.level)) !== null && _b !== void 0 ? _b : false;
+    return (isIsolationCategory && isAlternativeExercise && equipmentMatch && levelMatch);
 };
-const isAlternativeIsolationExerciseMatch = ({ exercise, exercisePrescription, equipments, level, muscleGroup, }) => {
-    var _a;
-    return (exercisePrescription.category === 'isolation' &&
-        isolationExerciseAlternatives[muscleGroup].includes(exercise.id) &&
-        (equipments.includes(exercise.equipment_category) ||
-            exercise.equipment_category === 'none' ||
-            exercise.equipment_category === 'other') &&
-        ((_a = exercise.level) === null || _a === void 0 ? void 0 : _a.includes(level)));
+/**
+ * Finds an exercise that matches the criteria and is not already used
+ */
+const findMatchingExercise = (exercises, criteria, context) => {
+    return exercises.find((exercise) => {
+        const matchesCriteria = isExerciseMatch(exercise, criteria);
+        const isNotUsed = !isExerciseUsed(exercise, context);
+        return matchesCriteria && isNotUsed;
+    });
+};
+/**
+ * Finds an alternative isolation exercise that matches the criteria
+ */
+const findAlternativeIsolationExercise = (exercises, criteria, context) => {
+    return exercises.find((exercise) => {
+        const matchesCriteria = isAlternativeIsolationExerciseMatch(exercise, criteria);
+        const isNotUsed = !isExerciseUsed(exercise, context);
+        return matchesCriteria && isNotUsed;
+    });
+};
+/**
+ * Selects the best exercise for a given prescription using a multi-pass strategy
+ */
+const pickExerciseForPrescription = (params) => {
+    const { sortedExercises, criteria, context } = params;
+    const exercises = sortedExercises[criteria.muscleGroup];
+    // Pass 1: Find exact match not used in program
+    const programContext = {
+        programUsedExerciseIds: context.programUsedExerciseIds,
+        excludedExerciseIds: context.excludedExerciseIds,
+    };
+    let exercise = findMatchingExercise(exercises, criteria, programContext);
+    if (exercise)
+        return exercise;
+    // Pass 2: Find exact match not used in routine (allow reuse in program)
+    const routineContext = {
+        routineUsedExerciseIds: context.routineUsedExerciseIds,
+        excludedExerciseIds: context.excludedExerciseIds,
+    };
+    exercise = findMatchingExercise(exercises, criteria, routineContext);
+    if (exercise)
+        return exercise;
+    // Pass 3: Find alternative isolation exercise not used in program
+    exercise = findAlternativeIsolationExercise(exercises, criteria, programContext);
+    if (exercise)
+        return exercise;
+    // Pass 4: Find alternative isolation exercise not used in routine
+    exercise = findAlternativeIsolationExercise(exercises, criteria, routineContext);
+    return exercise;
 };
-const generateProgram = ({ trainerPreset, selectedDays, selectedGoal, selectedLevel, selectedEquipments, exerciseStore, focusMuscle, }) => {
+exports.pickExerciseForPrescription = pickExerciseForPrescription;
+/**
+ * Generates a complete training program based on the provided parameters
+ */
+const generateProgram = (params) => {
     var _a;
+    const { trainerPreset, selectedDays, selectedGoal, selectedLevel, selectedEquipments, exerciseStore, focusMuscle, excludedExerciseIds, } = params;
     const routines = exports.programSplits[selectedDays];
     const program = {
         name: selectedDays,
         routines: [],
     };
-    // Have a map of muscle group to exercises sorted by exercise priority
-    const sortedExercises = Object.entries(trainerPreset.settings.exercise_priorities).reduce((acc, [muscleGroup, exercises]) => {
-        acc[muscleGroup] = exercises.map((exercise) => exerciseStore.find((e) => e.id === exercise));
-        return acc;
-    }, {});
-    // Then add remaining exercises to the map
-    Object.keys(sortedExercises).forEach((muscleGroup) => {
-        const remainingExercises = exerciseStore
-            .filter((e) => e.muscle_group === muscleGroup &&
-            !sortedExercises[muscleGroup].includes(e))
-            .sort((a, b) => b.priority - a.priority);
-        sortedExercises[muscleGroup].push(...remainingExercises);
-    });
-    const programUsedExercises = new Set();
+    const sortedExercises = (0, exports.getPrioritySortedExercises)(trainerPreset.settings.exercise_priorities, exerciseStore);
+    const programUsedExerciseIds = new Set();
     let programFocusMuscleExerciseCount = 0;
     const allErrors = [];
     for (const routine of routines) {
         const routineTemplate = trainerPreset.settings.templates[routine];
         let routineBarbellExerciseCount = 0;
-        const routineUsedExercises = new Set();
+        const routineUsedExerciseIds = new Set();
         const routineExercises = [];
         for (const exercisePrescription of routineTemplate.exercises) {
             const muscleGroup = getMuscleGroup({
@@ -143,55 +239,25 @@ const generateProgram = ({ trainerPreset, selectedDays, selectedGoal, selectedLe
             if (!muscleGroup) {
                 continue;
             }
-            // First pass: Try to find an exact match for the exercise that is not used in the program
-            let exercise = sortedExercises[muscleGroup].find((e) => isExerciseMatch({
-                exercisePrescription,
-                exercise: e,
-                equipments: selectedEquipments,
-                routineBarbellExerciseCount,
-                level: selectedLevel,
-                goal: selectedGoal,
-            }) && !programUsedExercises.has(e.title));
-            if (exercise === undefined) {
-                // Second pass
-                // By allowing the same exercise to be assigned in the same program more than once
-                const extendedMatchingExercise = sortedExercises[muscleGroup].find((e) => isExerciseMatch({
-                    exercisePrescription,
-                    exercise: e,
+            const exercise = (0, exports.pickExerciseForPrescription)({
+                sortedExercises,
+                criteria: {
+                    exerciseCategory: exercisePrescription.category,
                     equipments: selectedEquipments,
+                    muscleGroup,
                     routineBarbellExerciseCount,
                     level: selectedLevel,
                     goal: selectedGoal,
-                }) && !routineUsedExercises.has(e.title));
-                exercise = extendedMatchingExercise;
-            }
-            if (exercise === undefined) {
-                // Third pass
-                // Check if isolation exercise alternatives are available and not used in the program
-                const alternativeIsolationExercise = sortedExercises[muscleGroup].find((e) => isAlternativeIsolationExerciseMatch({
-                    exercise: e,
-                    exercisePrescription,
-                    equipments: selectedEquipments,
-                    level: selectedLevel,
-                    muscleGroup,
-                }) && !programUsedExercises.has(e.title));
-                exercise = alternativeIsolationExercise;
-            }
-            if (exercise === undefined) {
-                // Fourth pass
-                // Check if isolation exercise alternatives are available and not used in the workout
-                const extendedIsolationExercise = sortedExercises[muscleGroup].find((e) => isAlternativeIsolationExerciseMatch({
-                    exercise: e,
-                    exercisePrescription,
-                    equipments: selectedEquipments,
-                    level: selectedLevel,
-                    muscleGroup,
-                }) && !routineUsedExercises.has(e.title));
-                exercise = extendedIsolationExercise;
-            }
+                },
+                context: {
+                    programUsedExerciseIds,
+                    routineUsedExerciseIds,
+                    excludedExerciseIds,
+                },
+            });
             if (!!exercise) {
-                programUsedExercises.add(exercise.title);
-                routineUsedExercises.add(exercise.title);
+                programUsedExerciseIds.add(exercise.id);
+                routineUsedExerciseIds.add(exercise.id);
                 if (exercise.equipment_category === 'barbell')
                     routineBarbellExerciseCount++;
                 if (exercisePrescription.muscle_group === 'focus_muscle')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hevy-shared",
-  "version": "1.0.714",
+  "version": "1.0.715",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",