hevy-shared 1.0.648 → 1.0.649

package/built/index.d.ts

@@ -772,10 +772,6 @@ export interface WorkoutVideo {
     thumbnail_url: string;
 }
 export type WorkoutMedia = WorkoutImage | WorkoutVideo;
-export type PreviewWorkoutLike = {
-    username: string;
-    profile_pic: string;
-};
 export interface Workout {
     id: string;
     short_id: string | null;
@@ -783,9 +779,7 @@ export interface Workout {
     name: string;
     description?: string;
     like_count: number;
-    /** @deprecated 2.3.4 */
     like_images: string[];
-    preview_workout_likes: PreviewWorkoutLike[];
     comment_count: number;
     comments: WorkoutComment[];
     /** @deprecated 1.28.13 */

package/built/muscleSplits.d.ts

@@ -1,4 +1,4 @@
-import { MuscleGroup, SetType } from '.';
+import { MuscleGroup, SetType, SimplifiedMuscleGroup } from '.';
 interface SetCountableSet {
     indicator: SetType;
 }
@@ -7,18 +7,13 @@ interface SetCountableExercise {
     other_muscles: MuscleGroup[];
     sets: SetCountableSet[];
 }
-interface SetCountableWorkoutOrRoutine {
+export interface SetCountableWorkoutOrRoutine {
     exercises: SetCountableExercise[];
 }
-export declare const getSetContributionsForMuscleGroups: (muscle_group: MuscleGroup, other_muscles: MuscleGroup[]) => {
-    core: number;
-    shoulders: number;
-    arms: number;
-    legs: number;
-    back: number;
-    chest: number;
-};
-export declare const calculateSimplifiedMuscleSplit: (workoutsOrRoutines: SetCountableWorkoutOrRoutine[], shouldIncludeWarmupSets: boolean) => {
+export declare const calculateSetContributionsForSimplifiedMuscleGroups: ({ muscle_group, other_muscles, }: {
+    muscle_group: MuscleGroup;
+    other_muscles: MuscleGroup[];
+}) => {
     core: number;
     shoulders: number;
     arms: number;
@@ -26,5 +21,16 @@ export declare const calculateSimplifiedMuscleSplit: (workoutsOrRoutines: SetCou
     back: number;
     chest: number;
 };
-export declare const getSetCountPerMuscleGroups: (workout: SetCountableWorkoutOrRoutine, shouldIncludeWarmupSets: boolean) => Partial<{ [key in MuscleGroup]: number; }>;
+export declare const calculateSimplifiedMuscleSplit: ({ workoutsOrRoutines, includeWarmupSets, }: {
+    workoutsOrRoutines: SetCountableWorkoutOrRoutine[];
+    includeWarmupSets: boolean;
+}) => Record<SimplifiedMuscleGroup, number>;
+export declare const calculateSetContributionsForMuscleGroups: ({ muscleGroup, otherMuscles, }: {
+    muscleGroup: MuscleGroup;
+    otherMuscles: MuscleGroup[];
+}) => Record<MuscleGroup, number>;
+export declare const calculateSetCountPerMuscleGroups: ({ workoutsOrRoutines, includeWarmupSets, }: {
+    workoutsOrRoutines: SetCountableWorkoutOrRoutine[];
+    includeWarmupSets: boolean;
+}) => Record<MuscleGroup, number>;
 export {};

package/built/muscleSplits.js

@@ -3,10 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSetCountPerMuscleGroups = exports.calculateSimplifiedMuscleSplit = exports.getSetContributionsForMuscleGroups = void 0;
+exports.calculateSetCountPerMuscleGroups = exports.calculateSetContributionsForMuscleGroups = exports.calculateSimplifiedMuscleSplit = exports.calculateSetContributionsForSimplifiedMuscleGroups = void 0;
 const intersection_1 = __importDefault(require("lodash/intersection"));
 const _1 = require(".");
-const getSetContributionsForMuscleGroups = (muscle_group, other_muscles) => {
+const calculateSetContributionsForSimplifiedMuscleGroups = ({ muscle_group, other_muscles, }) => {
     const getContribution = (mg) => {
         if (mg.includes(muscle_group)) {
             return 1;
@@ -28,8 +28,8 @@ const getSetContributionsForMuscleGroups = (muscle_group, other_muscles) => {
         chest: getContribution(_1.chestMuscles),
     };
 };
-exports.getSetContributionsForMuscleGroups = getSetContributionsForMuscleGroups;
-const calculateSimplifiedMuscleSplit = (workoutsOrRoutines, shouldIncludeWarmupSets) => {
+exports.calculateSetContributionsForSimplifiedMuscleGroups = calculateSetContributionsForSimplifiedMuscleGroups;
+const calculateSimplifiedMuscleSplit = ({ workoutsOrRoutines, includeWarmupSets, }) => {
     const totals = {
         core: 0,
         shoulders: 0,
@@ -40,11 +40,14 @@ const calculateSimplifiedMuscleSplit = (workoutsOrRoutines, shouldIncludeWarmupS
     };
     for (const workoutOrRoutine of workoutsOrRoutines) {
         for (const exercise of workoutOrRoutine.exercises) {
-            const trimmedSets = shouldIncludeWarmupSets
+            const trimmedSets = includeWarmupSets
                 ? exercise.sets
                 : exercise.sets.filter((s) => s.indicator !== 'warmup');
             const setCount = trimmedSets.length;
-            const contributions = (0, exports.getSetContributionsForMuscleGroups)(exercise.muscle_group, exercise.other_muscles);
+            const contributions = (0, exports.calculateSetContributionsForSimplifiedMuscleGroups)({
+                muscle_group: exercise.muscle_group,
+                other_muscles: exercise.other_muscles,
+            });
             totals.core += contributions.core * setCount;
             totals.shoulders += contributions.shoulders * setCount;
             totals.arms += contributions.arms * setCount;
@@ -56,16 +59,42 @@ const calculateSimplifiedMuscleSplit = (workoutsOrRoutines, shouldIncludeWarmupS
     return totals;
 };
 exports.calculateSimplifiedMuscleSplit = calculateSimplifiedMuscleSplit;
-const getSetCountPerMuscleGroups = (workout, shouldIncludeWarmupSets) => {
-    return workout.exercises.reduce((acc, e) => {
-        const trimmedSets = shouldIncludeWarmupSets
-            ? e.sets
-            : e.sets.filter((s) => s.indicator !== 'warmup');
-        acc[e.muscle_group] = (acc[e.muscle_group] || 0) + trimmedSets.length;
-        e.other_muscles.forEach((muscle) => {
-            acc[muscle] = (acc[muscle] || 0) + trimmedSets.length / 2;
-        });
+const calculateSetContributionsForMuscleGroups = ({ muscleGroup, otherMuscles, }) => {
+    const getContribution = (mg) => {
+        if (mg === muscleGroup) {
+            return 1;
+        }
+        else if (otherMuscles.includes(mg)) {
+            return 0.5;
+        }
+        return 0;
+    };
+    return _1.muscleGroups.reduce((acc, mg) => {
+        acc[mg] = getContribution(mg);
+        return acc;
+    }, {});
+};
+exports.calculateSetContributionsForMuscleGroups = calculateSetContributionsForMuscleGroups;
+const calculateSetCountPerMuscleGroups = ({ workoutsOrRoutines, includeWarmupSets, }) => {
+    const totals = _1.muscleGroups.reduce((acc, muscleGroup) => {
+        acc[muscleGroup] = 0;
         return acc;
     }, {});
+    for (const workoutOrRoutine of workoutsOrRoutines) {
+        for (const exercise of workoutOrRoutine.exercises) {
+            const trimmedSets = includeWarmupSets
+                ? exercise.sets
+                : exercise.sets.filter((s) => s.indicator !== 'warmup');
+            const setCount = trimmedSets.length;
+            const contributions = (0, exports.calculateSetContributionsForMuscleGroups)({
+                muscleGroup: exercise.muscle_group,
+                otherMuscles: exercise.other_muscles,
+            });
+            for (const muscleGroup of _1.muscleGroups) {
+                totals[muscleGroup] += contributions[muscleGroup] * setCount;
+            }
+        }
+    }
+    return totals;
 };
-exports.getSetCountPerMuscleGroups = getSetCountPerMuscleGroups;
+exports.calculateSetCountPerMuscleGroups = calculateSetCountPerMuscleGroups;

package/built/tests/muscleSplit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/built/tests/muscleSplit.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const muscleSplits_1 = require("../muscleSplits");
+class SetCountableWorkoutOrRoutineBuilder {
+    constructor() {
+        this.exercises = [];
+    }
+    addExercise(muscle_group, other_muscles, sets) {
+        this.exercises.push({
+            muscle_group,
+            other_muscles,
+            sets: sets.map((indicator) => ({ indicator })),
+        });
+        return this;
+    }
+    build() {
+        return {
+            exercises: this.exercises,
+        };
+    }
+}
+describe('muscleSplits', () => {
+    describe('calculateSetContributionsForSimplifiedMuscleGroups', () => {
+        it('should return 1 for the main muscle group', () => {
+            const contributions = (0, muscleSplits_1.calculateSetContributionsForSimplifiedMuscleGroups)({
+                muscle_group: 'chest',
+                other_muscles: [],
+            });
+            expect(contributions.chest).toBe(1);
+            expect(contributions.back).toBe(0);
+            expect(contributions.shoulders).toBe(0);
+            expect(contributions.arms).toBe(0);
+            expect(contributions.legs).toBe(0);
+            expect(contributions.core).toBe(0);
+        });
+        it('should return 0.5 for other muscle groups', () => {
+            const contributions = (0, muscleSplits_1.calculateSetContributionsForSimplifiedMuscleGroups)({
+                muscle_group: 'shoulders',
+                other_muscles: ['triceps'],
+            });
+            expect(contributions.shoulders).toBe(1);
+            expect(contributions.arms).toBe(0.5);
+        });
+        it('should return 1/6 for full body exercises', () => {
+            const contributions = (0, muscleSplits_1.calculateSetContributionsForSimplifiedMuscleGroups)({
+                muscle_group: 'full_body',
+                other_muscles: [],
+            });
+            const expected = 1 / 6;
+            expect(contributions.chest).toBe(expected);
+            expect(contributions.back).toBe(expected);
+            expect(contributions.shoulders).toBe(expected);
+            expect(contributions.arms).toBe(expected);
+            expect(contributions.legs).toBe(expected);
+            expect(contributions.core).toBe(expected);
+        });
+    });
+    describe('calculateSimplifiedMuscleSplit', () => {
+        it('should calculate the split correctly', () => {
+            const workout = new SetCountableWorkoutOrRoutineBuilder()
+                .addExercise('chest', ['triceps'], ['normal', 'normal', 'normal'])
+                .addExercise('lats', ['biceps'], ['normal', 'normal'])
+                .build();
+            const split = (0, muscleSplits_1.calculateSimplifiedMuscleSplit)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: false,
+            });
+            expect(split.chest).toBe(3);
+            expect(split.arms).toBe(3 * 0.5 + 2 * 0.5); // 1.5 from chest day, 1 from back day
+            expect(split.back).toBe(2);
+        });
+        it('should handle warmup sets', () => {
+            const workout = new SetCountableWorkoutOrRoutineBuilder()
+                .addExercise('chest', ['triceps'], ['warmup', 'normal', 'normal', 'failure'])
+                .build();
+            const splitWithWarmup = (0, muscleSplits_1.calculateSimplifiedMuscleSplit)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: true,
+            });
+            expect(splitWithWarmup.chest).toBe(4);
+            expect(splitWithWarmup.arms).toBe(4 * 0.5);
+            const splitWithoutWarmup = (0, muscleSplits_1.calculateSimplifiedMuscleSplit)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: false,
+            });
+            expect(splitWithoutWarmup.chest).toBe(3);
+            expect(splitWithoutWarmup.arms).toBe(3 * 0.5);
+        });
+        it('should count a set as 1 for a simplified group even if primary and other muscles are in the same group', () => {
+            const workout = new SetCountableWorkoutOrRoutineBuilder()
+                .addExercise('quadriceps', ['hamstrings', 'glutes'], // also in legs
+            ['normal'])
+                .build();
+            const split = (0, muscleSplits_1.calculateSimplifiedMuscleSplit)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: false,
+            });
+            expect(split.legs).toBe(1);
+            expect(split.chest).toBe(0);
+            expect(split.back).toBe(0);
+            expect(split.shoulders).toBe(0);
+            expect(split.arms).toBe(0);
+            expect(split.core).toBe(0);
+        });
+    });
+    describe('calculateSetContributionsForMuscleGroups', () => {
+        it('should return 1 for the main muscle group and 0.5 for others', () => {
+            const contributions = (0, muscleSplits_1.calculateSetContributionsForMuscleGroups)({
+                muscleGroup: 'chest',
+                otherMuscles: ['shoulders', 'triceps'],
+            });
+            expect(contributions.chest).toBe(1);
+            expect(contributions.shoulders).toBe(0.5);
+            expect(contributions.triceps).toBe(0.5);
+            expect(contributions.lats).toBe(0);
+        });
+    });
+    describe('calculateSetCountPerMuscleGroups', () => {
+        it('should calculate the set count per muscle group', () => {
+            const workout = new SetCountableWorkoutOrRoutineBuilder()
+                .addExercise('chest', ['shoulders', 'triceps'], ['normal', 'normal', 'normal'])
+                .addExercise('lats', ['biceps'], ['normal', 'normal'])
+                .build();
+            const counts = (0, muscleSplits_1.calculateSetCountPerMuscleGroups)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: false,
+            });
+            expect(counts.chest).toBe(3);
+            expect(counts.shoulders).toBe(3 * 0.5);
+            expect(counts.triceps).toBe(3 * 0.5);
+            expect(counts.lats).toBe(2);
+            expect(counts.biceps).toBe(2 * 0.5);
+            expect(counts.abdominals).toBe(0);
+        });
+        it('should handle warmup sets correctly', () => {
+            const workout = new SetCountableWorkoutOrRoutineBuilder()
+                .addExercise('chest', ['shoulders', 'triceps'], ['warmup', 'normal', 'normal'])
+                .build();
+            const countsWithWarmup = (0, muscleSplits_1.calculateSetCountPerMuscleGroups)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: true,
+            });
+            expect(countsWithWarmup.chest).toBe(3);
+            expect(countsWithWarmup.shoulders).toBe(3 * 0.5);
+            const countsWithoutWarmup = (0, muscleSplits_1.calculateSetCountPerMuscleGroups)({
+                workoutsOrRoutines: [workout],
+                includeWarmupSets: false,
+            });
+            expect(countsWithoutWarmup.chest).toBe(2);
+            expect(countsWithoutWarmup.shoulders).toBe(2 * 0.5);
+        });
+    });
+});

package/package.json

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