hevy-shared 1.0.962 → 1.0.964

package/built/filterExercises.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.popularExerciseTemplateIds = exports.filterExercises = void 0;
-const lodash_1 = require("lodash");
+exports.popularExerciseTemplateIds = exports.getExerciseMatches = void 0;
 const utils_1 = require("./utils");
-const filterExercises = ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }) => {
+const lodash_1 = require("lodash");
+const getExerciseMatches = ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }) => {
     let result = exercises;
     result = filterExercisesWithMuscleGroup(muscleGroupFilter, result);
     result = filterExercisesWithEquipment(equipmentType, result);
     const normalizedSearchText = normalizeSearchText(searchText, language);
-    result = filterExercisesWithSearchText(normalizedSearchText, result, language);
-    result = orderExercisesWithSearchText(normalizedSearchText, result);
-    return result;
+    let matches = filterExercisesWithSearchText(normalizedSearchText, result, language);
+    matches = orderExercisesWithSearchText(normalizedSearchText, matches);
+    return matches;
 };
-exports.filterExercises = filterExercises;
+exports.getExerciseMatches = getExerciseMatches;
 const filterExercisesWithMuscleGroup = (muscleGroup, exercises) => {
     if (muscleGroup === 'all_muscles') {
         return exercises;
@@ -25,41 +25,52 @@ const filterExercisesWithEquipment = (equipmentType, exercises) => {
     }
     return exercises.filter((rd) => rd.equipment_category === equipmentType);
 };
+// Old filter exercise functionality, will be removed when new feature goes live
 const filterExercisesWithSearchText = (searchText, exercises, language) => {
     if (searchText.length === 0) {
-        return exercises;
+        return exercises.map((e) => ({ exercise: e, matchType: 'other' }));
     }
-    return exercises.filter((e) => {
+    const matches = [];
+    for (const e of exercises) {
         const searchableSearchText = searchable(searchText);
         const searchableEnglishTitle = searchable(e.title);
-        const searchableLocalizedTitleMap = {
-            en: searchable(e.title),
-            es: e.es_title ? searchable(e.es_title) : undefined,
-            de: e.de_title ? searchable(e.de_title) : undefined,
-            fr: e.fr_title ? searchable(e.fr_title) : undefined,
-            it: e.it_title ? searchable(e.it_title) : undefined,
-            pt: e.pt_title ? searchable(e.pt_title) : undefined,
-            tr: e.tr_title ? searchable(e.tr_title) : undefined,
-            zh_CN: e.zh_cn_title ? searchable(e.zh_cn_title) : undefined,
-            zh_TW: e.zh_tw_title ? searchable(e.zh_tw_title) : undefined,
-            ru: e.ru_title ? searchable(e.ru_title) : undefined,
-            ja: e.ja_title ? searchable(e.ja_title) : undefined,
-            ko: e.ko_title ? searchable(e.ko_title) : undefined,
-        };
+        const searchableLocalizedTitleMap = !e.is_custom
+            ? {
+                en: searchable(e.title),
+                es: e.es_title ? searchable(e.es_title) : undefined,
+                de: e.de_title ? searchable(e.de_title) : undefined,
+                fr: e.fr_title ? searchable(e.fr_title) : undefined,
+                it: e.it_title ? searchable(e.it_title) : undefined,
+                pt: e.pt_title ? searchable(e.pt_title) : undefined,
+                tr: e.tr_title ? searchable(e.tr_title) : undefined,
+                zh_CN: e.zh_cn_title ? searchable(e.zh_cn_title) : undefined,
+                zh_TW: e.zh_tw_title ? searchable(e.zh_tw_title) : undefined,
+                ru: e.ru_title ? searchable(e.ru_title) : undefined,
+                ja: e.ja_title ? searchable(e.ja_title) : undefined,
+                ko: e.ko_title ? searchable(e.ko_title) : undefined,
+            }
+            : {
+                en: searchable(e.title),
+            };
         const searchableLocalizedTitle = searchableLocalizedTitleMap[language] || searchableLocalizedTitleMap.en;
         const searchableLocalizedMuscleGroupName = searchable(e.localized_muscle_group_name);
         const searchableMuscleGroup = searchable(e.muscle_group);
         const searchableMisspelledDumbbellEquipment = e.equipment_category === 'dumbbell' ? 'dumbell' : '';
-        const searchableTags = e.manual_tag ? searchable(e.manual_tag) : '';
-        const searchableAka = e.aka ? searchable(e.aka) : '';
+        const searchableTags = !e.is_custom && e.manual_tag ? searchable(e.manual_tag) : '';
+        const searchableAka = !e.is_custom && e.aka ? searchable(e.aka) : '';
         if (searchableLocalizedTitle.includes(searchableSearchText) ||
-            searchableEnglishTitle.includes(searchableSearchText) ||
-            searchableLocalizedMuscleGroupName.includes(searchableSearchText) ||
+            searchableEnglishTitle.includes(searchableSearchText)) {
+            matches.push({ exercise: e, matchType: 'title' });
+            continue;
+        }
+        else if (searchableLocalizedMuscleGroupName.includes(searchableSearchText) ||
             searchableMuscleGroup.includes(searchableSearchText)) {
-            return true;
+            matches.push({ exercise: e, matchType: 'muscle_group' });
+            continue;
         }
         if (e.is_custom && 'custom'.includes(searchableSearchText)) {
-            return true;
+            matches.push({ exercise: e, matchType: 'custom' });
+            continue;
         }
         const splitSearch = searchableSearchText.split(' ');
         const splitTitle = [
@@ -75,28 +86,29 @@ const filterExercisesWithSearchText = (searchText, exercises, language) => {
         // title ['arnold', 'press', '(barbell)']
         // search ['press', 'bar']
         if ((0, lodash_1.intersectionWith)(splitSearch, splitTitle, (search, title) => title.includes(search)).length === splitSearch.length) {
-            return true;
+            matches.push({ exercise: e, matchType: 'other' });
+            continue;
         }
-        return false;
-    });
+    }
+    return matches;
 };
-const orderExercisesWithSearchText = (searchText, exercises) => {
+const orderExercisesWithSearchText = (searchText, exerciseMatches) => {
     if (searchText.length === 0) {
-        return exercises;
+        return exerciseMatches;
     }
-    return exercises
-        .reduce((accu, currentExercise) => {
-        const lowercaseTitle = currentExercise.title.toLowerCase();
+    return exerciseMatches
+        .reduce((accu, currentMatch) => {
+        const lowercaseTitle = currentMatch.exercise.title.toLowerCase();
         if (lowercaseTitle.startsWith(searchText)) {
             accu.push({
-                exercise: currentExercise,
-                weight: currentExercise.priority * 2,
+                exercise: currentMatch,
+                weight: currentMatch.exercise.priority * 2,
             });
             return accu;
         }
         accu.push({
-            exercise: currentExercise,
-            weight: currentExercise.priority,
+            exercise: currentMatch,
+            weight: currentMatch.exercise.priority,
         });
         return accu;
     }, [])
@@ -126,24 +138,24 @@ const searchable = (str) => {
  * users who don't have any workouts logged.
  */
 exports.popularExerciseTemplateIds = [
-    'B8127AD1',
-    '11A123F3',
-    'D04AC939',
-    '75A4F6C4',
-    '422B08F1',
-    'C7973E0E',
-    '07B38369',
-    '3601968B',
-    '6A6C31A5',
-    '0393F233',
-    '37FCC2BB',
-    '55E6546F',
-    '94B7239B',
-    'C6272009',
-    '878CD1D0',
-    '651F844C',
-    '79D0BB3A',
-    '93A552C6',
-    '7E3BC8B6',
+    'B8127AD1', // Lying Leg Curl (Machine)"
+    '11A123F3', // Seated Leg Curl (Machine)"
+    'D04AC939', // Squat (Barbell)"
+    '75A4F6C4', // Leg Extension (Machine)"
+    '422B08F1', // Lateral Raise (Dumbbell)"
+    'C7973E0E', // Leg Press (Machine)"
+    '07B38369', // Incline Bench Press (Dumbbell)"
+    '3601968B', // Bench Press (Dumbbell)"
+    '6A6C31A5', // Lat Pulldown (Cable)"
+    '0393F233', // Seated Cable Row - V Grip (Cable)"
+    '37FCC2BB', // Bicep Curl (Dumbbell)"
+    '55E6546F', // Bent Over Row (Barbell)"
+    '94B7239B', // Triceps Rope Pushdown"
+    'C6272009', // Deadlift (Barbell)"
+    '878CD1D0', // Shoulder Press (Dumbbell)"
+    '651F844C', // Cable Fly Crossovers"
+    '79D0BB3A', // Bench Press (Barbell)"
+    '93A552C6', // Triceps Pushdown"
+    '7E3BC8B6', // Hammer Curl (Dumbbell)"
     'BE640BA0', // Face Pull
 ];

package/built/hevyTrainer.d.ts

@@ -0,0 +1,250 @@
+import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength } from '.';
+export type HevyTrainerExerciseCategory = typeof hevyTrainerExerciseCategories[number];
+export type HevyTrainerRoutineName = typeof routineNames[number];
+export declare const workoutDurationOptions: readonly [40, 60, 80];
+export type WorkoutDurationMinutes = typeof workoutDurationOptions[number];
+export declare const trainerGymTypes: readonly ["home_gym", "garage_gym", "commercial_gym", "full_gym"];
+export type TrainerGymType = typeof trainerGymTypes[number];
+export declare const granularEquipmentDefaults: {
+    [key in TrainerGymType]: GranularEquipment[];
+};
+export declare const trainerEquipmentToGranularEquipments: (equipments: HevyTrainerProgramEquipment[]) => GranularEquipment[];
+/**
+ * Converts granular equipment values back to the old HevyTrainerProgramEquipment
+ * types for backwards compatibility with old mobile clients.
+ */
+export declare const granularEquipmentsToTrainerEquipments: (granularEquipments: GranularEquipment[]) => HevyTrainerProgramEquipment[];
+export declare const hevyTrainerExerciseCategories: readonly ["compound", "isolation"];
+export declare const defaultDurationPerFrequency: Record<WeeklyTrainingFrequency, WorkoutDurationMinutes>;
+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 | 'all';
+    equipments: GranularEquipment[];
+    routineBarbellExerciseCount: number;
+    level: TrainingLevel;
+    goal: TrainingGoal;
+    muscleGroup: MuscleGroup;
+    frequency: WeeklyTrainingFrequency;
+}
+export interface ExerciseSelectionContext {
+    programUsedExerciseIds?: Set<string>;
+    routineUsedExerciseIds?: Set<string>;
+    excludedExerciseIds?: Set<string>;
+}
+export interface ExerciseSelectionParams<T extends HevyTrainerLibraryExercise> {
+    sortedExercises: Record<MuscleGroup, T[]>;
+    handPickedExercises?: T[];
+    criteria: ExerciseSelectionCriteria;
+    context: ExerciseSelectionContext;
+}
+export interface ExerciseSelectionTraceEntry {
+    pass: 1 | 2 | 3 | 4 | 5 | 6;
+    label: string;
+    candidatePoolSize: number;
+    selectedExerciseId?: string;
+}
+export interface ExerciseSelectionTrace {
+    entries: ExerciseSelectionTraceEntry[];
+    selectedPass?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export interface ProgramGenerationParams<T extends HevyTrainerLibraryExercise> {
+    trainerAlgorithmSettings: TrainerAlgorithmSettings;
+    frequency: WeeklyTrainingFrequency;
+    goal: TrainingGoal;
+    level: TrainingLevel;
+    equipments: GranularEquipment[];
+    workoutDurationMinutes: WorkoutDurationMinutes;
+    restTimerLength: RestTimerLength;
+    exerciseStore: T[];
+    focusMuscle?: SimplifiedMuscleGroup;
+    excludedExerciseIds?: Set<string>;
+    /**
+     * When enabled, includes exercise selection trace breadcrumbs in the result
+     * for debugging. Intended for troubleshooting on backoffice; keep off in
+     * normal usage on the app.
+     */
+    debugExerciseSelectionTrace?: boolean;
+}
+export interface ProgramExerciseSelectionTraceRecord {
+    routine: HevyTrainerRoutineName;
+    prescriptionIndex: number;
+    prescription: ExercisePrescription;
+    resolvedMuscleGroup: MuscleGroup;
+    criteria: ExerciseSelectionCriteria;
+    selectedExerciseId?: string;
+    trace: ExerciseSelectionTrace;
+}
+export type TrainerProgramAttemptWithTraces = TrainerProgramAttempt & {
+    exerciseSelectionTraces: ProgramExerciseSelectionTraceRecord[];
+};
+export type FrequencyString = 'one_day' | 'two_days' | 'three_days' | 'four_days' | 'five_days' | 'six_days';
+export declare const frequencyMap: Record<WeeklyTrainingFrequency, FrequencyString>;
+export declare const programSplits: Record<WeeklyTrainingFrequency, HevyTrainerRoutineName[]>;
+export type SetsPerGoal = {
+    [key in TrainingGoal]: number;
+};
+export type SetsPerFrequency = {
+    [key in FrequencyString]: SetsPerGoal;
+};
+export interface RepRange {
+    rep_range_start: number;
+    rep_range_end: number;
+}
+export type RepRangesPerCategory = {
+    [key in HevyTrainerExerciseCategory]: RepRange;
+};
+export type RepRanges = {
+    [key in TrainingGoal]: RepRangesPerCategory;
+};
+export type RestTimersPerCategory = {
+    [key in HevyTrainerExerciseCategory]: number;
+};
+export type CategoryPerRestTimerLength = {
+    [key in RestTimerLength]: RestTimersPerCategory;
+};
+export type RestTimers = {
+    [key in TrainingGoal]: CategoryPerRestTimerLength;
+};
+export type ExercisePriorities = {
+    [key in MuscleGroup]: exerciseId[];
+};
+export type ExerciseNotes = {
+    [key in exerciseId]: string;
+};
+export interface ExercisePrescription {
+    muscle_group: MuscleGroup | 'focus_muscle';
+    category: HevyTrainerExerciseCategory;
+    warmup_set_count?: number;
+    min_workout_duration_limit?: WorkoutDurationMinutes;
+}
+export type ExerciseReplacements = {
+    [key in exerciseId]: exerciseId[];
+};
+export interface WorkoutTemplate {
+    exercises: ExercisePrescription[];
+    notes?: string;
+}
+export type Templates = {
+    [key in HevyTrainerRoutineName]: WorkoutTemplate;
+};
+export interface BackofficeTrainerPreset {
+    id?: number;
+    username: string;
+    title?: string;
+    is_default?: boolean;
+    updated_at?: string;
+    settings: TrainerAlgorithmSettings;
+}
+export interface TrainerAlgorithmSettings {
+    sets: SetsPerFrequency;
+    rep_ranges: RepRanges;
+    rest_timers: RestTimers;
+    templates: Templates;
+    exercise_priorities: ExercisePriorities;
+    exercise_notes: ExerciseNotes;
+    exercise_replacements: ExerciseReplacements;
+}
+export interface TrainerProgramExercise {
+    exerciseTemplate: HevyTrainerLibraryExercise;
+    muscleGroup: MuscleGroup | 'focus_muscle';
+    category: HevyTrainerExerciseCategory;
+    sets: number;
+    warmupSetCount?: number;
+    repRangeStart: number;
+    repRangeEnd: number;
+    restTimerSeconds: number;
+    notes?: string;
+}
+export interface TrainerProgramRoutine {
+    name: HevyTrainerRoutineName;
+    exercises: TrainerProgramExercise[];
+    notes?: string;
+}
+export interface TrainerProgram {
+    name: WeeklyTrainingFrequency;
+    routines: TrainerProgramRoutine[];
+}
+export declare const getTrainerSetCount: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, frequency: WeeklyTrainingFrequency) => number;
+export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => RepRange;
+export declare const getTrainerRestTimerSeconds: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, length: RestTimerLength, exerciseCategory: HevyTrainerExerciseCategory) => number;
+/**
+ * Normalizes the exercise category to a HevyTrainerExerciseCategory
+ * - Treat custom exercises and exercises with no category as `compound`
+ * - Treat `assistance-compound` as `compound`
+ * - Treat `isolation` as `isolation`
+ * @param exercise - The exercise to normalize the category for
+ * @returns The normalized exercise category
+ */
+export declare const normalizeExerciseCategory: (exercise: {
+    is_custom: boolean;
+    category?: ExerciseCategory;
+}) => HevyTrainerExerciseCategory;
+/**
+ * Checks if an exercise is compatible with the user's selected granular equipments
+ *
+ * - If the exercise has no granular equipments, it is compatible no matter what the user has selected
+ * - Otherwise, the exercise is only allowed if the user has all the granular equipments
+ */
+export declare const isEquipmentCompatible: (exercise: HevyTrainerLibraryExercise, userSelectedGranularEquipments: GranularEquipment[]) => boolean;
+/**
+ * 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
+ */
+type PickExerciseResult<T extends HevyTrainerLibraryExercise> = {
+    exercise?: T;
+    trace: ExerciseSelectionTrace;
+};
+export declare function pickExerciseForPrescription<T extends HevyTrainerLibraryExercise>(params: ExerciseSelectionParams<T> & {
+    withTrace: true;
+}): PickExerciseResult<T>;
+export declare function pickExerciseForPrescription<T extends HevyTrainerLibraryExercise>(params: ExerciseSelectionParams<T>): T | undefined;
+export type HevyTrainerLibraryExercise = Pick<LibraryExercise, 'id' | 'title' | 'priority' | 'muscle_group' | 'other_muscles' | 'exercise_type' | 'equipment_category' | 'category' | 'level' | 'goal' | 'granular_equipments'>;
+export interface ExercisePrescriptionError {
+    type: 'exercise_not_found';
+    prescription: ExercisePrescription;
+    muscleGroup: MuscleGroup;
+    context: {
+        goal: TrainingGoal;
+        level: TrainingLevel;
+        equipments: GranularEquipment[];
+        focusMuscle?: SimplifiedMuscleGroup;
+    };
+}
+export interface TrainerProgramExerciseResult {
+    success: true;
+    exercise: TrainerProgramExercise;
+}
+export interface TrainerProgramExerciseError {
+    success: false;
+    error: ExercisePrescriptionError;
+}
+export type TrainerProgramExerciseAttempt = TrainerProgramExerciseResult | TrainerProgramExerciseError;
+export interface TrainerProgramResult {
+    success: true;
+    program: TrainerProgram;
+}
+export interface TrainerProgramError {
+    success: false;
+    errors: ExercisePrescriptionError[];
+    partialProgram: TrainerProgram;
+}
+export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
+/**
+ * Generates a complete training program based on the provided parameters
+ * - debugExerciseSelectionTrace: true -> includes exercise selection trace breadcrumbs in the result for debugging.
+ * - debugExerciseSelectionTrace: false -> no exercise selection trace breadcrumbs in the result.
+ */
+export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T> & {
+    debugExerciseSelectionTrace: true;
+}): TrainerProgramAttemptWithTraces;
+export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt;
+export {};