@abyss-project/training 1.0.0 → 1.0.2

package/dist/types/interface/models/training-program-schedule.model.d.ts

@@ -0,0 +1,18 @@
+import { DayOfWeek, ScheduleType } from '../../enum';
+import { ITrainingProgram } from './training-program.model';
+import { IWorkoutTemplate } from './workout-template.model';
+export interface ITrainingProgramSchedule {
+    id?: string;
+    trainingProgramId: string;
+    workoutTemplateId: string;
+    scheduleType: ScheduleType;
+    dayOfWeek: DayOfWeek | null;
+    cycleDay: number | null;
+    monthDay: number | null;
+    weekNumber: number | null;
+    order: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    trainingProgram?: ITrainingProgram;
+    workoutTemplate?: IWorkoutTemplate;
+}

package/dist/types/interface/models/training-program-schedule.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface/models/training-program.model.d.ts

@@ -0,0 +1,17 @@
+import { TrainingProgramStatus } from '../../enum';
+import { IUser } from './user.model';
+import { ITrainingProgramSchedule } from './training-program-schedule.model';
+export interface ITrainingProgram {
+    id?: string;
+    name: string;
+    description: string | null;
+    userId: string | null;
+    status: TrainingProgramStatus;
+    durationWeeks: number;
+    startDate: Date | null;
+    endDate: Date | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+    user?: IUser;
+    trainingProgramSchedules?: ITrainingProgramSchedule[];
+}

package/dist/types/interface/models/training-program.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface/models/workout-exercise.model.d.ts

@@ -1,21 +1,18 @@
-import { IWorkoutTemplate } from './workout-template.model';
 import { IExercise } from './exercise.model';
-import { ExerciseGroupType } from '../../enum/exercise-group-type.enum';
+import { IWorkoutGroup } from './workout-group.model';
 export interface IWorkoutExercise {
     id?: string;
-    workoutTemplateId: string;
+    workoutGroupId: string;
     exerciseId: string;
     order: number;
-    groupType: ExerciseGroupType;
-    groupId: string | null;
-    groupOrder: number | null;
-    plannedSets: number | null;
     plannedReps: number | null;
     plannedWeight: number | null;
-    plannedRestTime: number | null;
+    plannedDuration: number | null;
+    plannedDistance: number | null;
+    plannedCalories: number | null;
     notes: string | null;
     createdAt?: Date;
     updatedAt?: Date;
-    workoutTemplate?: IWorkoutTemplate;
+    workoutGroup?: IWorkoutGroup;
     exercise?: IExercise;
 }

package/dist/types/interface/models/workout-group.model.d.ts

@@ -0,0 +1,18 @@
+import { IWorkoutSection } from './workout-section.model';
+import { IWorkoutExercise } from './workout-exercise.model';
+import { WorkoutGroupType } from '../../enum';
+export interface IWorkoutGroup {
+    id?: string;
+    workoutSectionId: string;
+    name: string | null;
+    order: number;
+    plannedSets: number;
+    plannedRestTime: number | null;
+    type: WorkoutGroupType;
+    timeCap: number | null;
+    intervalSeconds: number | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+    workoutSection?: IWorkoutSection;
+    workoutExercises?: IWorkoutExercise[];
+}

package/dist/types/interface/models/workout-group.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface/models/workout-section.model.d.ts

@@ -0,0 +1,13 @@
+import { IWorkoutTemplate } from './workout-template.model';
+import { IWorkoutGroup } from './workout-group.model';
+export interface IWorkoutSection {
+    id?: string;
+    workoutTemplateId: string;
+    name: string;
+    description: string | null;
+    order: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    workoutTemplate?: IWorkoutTemplate;
+    workoutGroups?: IWorkoutGroup[];
+}

package/dist/types/interface/models/workout-section.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface/models/workout-session.model.d.ts

@@ -1,14 +1,12 @@
-import { WorkoutSessionStatus } from '../../enum/workout-session-status.enum';
-import { IExerciseSet } from './exercise-set.model';
 import { IUser } from './user.model';
 import { IWorkoutTemplate } from './workout-template.model';
+import { ITemplateSnapshot, IWorkoutSessionSet } from '../template-snapshot.interface';
 export interface IWorkoutSession {
     id?: string;
     userId: string;
     workoutTemplateId: string | null;
-    name: string;
-    status: WorkoutSessionStatus;
-    scheduledAt: Date | null;
+    templateSnapshot: ITemplateSnapshot;
+    sets: IWorkoutSessionSet[];
     startedAt: Date | null;
     completedAt: Date | null;
     duration: number | null;
@@ -17,5 +15,4 @@ export interface IWorkoutSession {
     updatedAt?: Date;
     user?: IUser;
     workoutTemplate?: IWorkoutTemplate;
-    exerciseSet?: IExerciseSet[];
 }

package/dist/types/interface/models/workout-template.model.d.ts

@@ -1,6 +1,6 @@
 import { IUser } from './user.model';
-import { IWorkoutExercise } from './workout-exercise.model';
 import { IWorkoutSession } from './workout-session.model';
+import { IWorkoutSection } from './workout-section.model';
 export interface IWorkoutTemplate {
     id?: string;
     name: string;
@@ -11,6 +11,6 @@ export interface IWorkoutTemplate {
     createdAt?: Date;
     updatedAt?: Date;
     user?: IUser;
-    workoutExercise?: IWorkoutExercise[];
+    workoutSections?: IWorkoutSection[];
     workoutSession?: IWorkoutSession[];
 }

package/dist/types/interface/personal-record.interface.d.ts

@@ -0,0 +1,29 @@
+import { PersonalRecordType } from '../enum';
+export interface PersonalRecord {
+    id: string;
+    recordType: PersonalRecordType;
+    value: number;
+    unit: string;
+    achievedAt: string;
+    sessionId: string;
+    previousValue: number | null;
+    previousAchievedAt: string | null;
+    improvementPercent: number | null;
+}
+export interface ExercisePersonalRecords {
+    exerciseId: string;
+    exerciseName: string;
+    exerciseUserId: string | null;
+    exerciseImageUrl: string | null;
+    primaryMuscleGroups: string[];
+    totalSessions: number;
+    firstPerformed: string | null;
+    lastPerformed: string | null;
+    records: PersonalRecord[];
+}
+export interface UserPersonalRecords {
+    totalRecords: number;
+    exercisesWithRecords: number;
+    latestRecordDate: string | null;
+    exercises: ExercisePersonalRecords[];
+}

package/dist/types/interface/personal-record.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/interface/template-snapshot.interface.d.ts

@@ -0,0 +1,36 @@
+import { IWorkoutTemplate } from './models/workout-template.model';
+import { IWorkoutSection } from './models/workout-section.model';
+import { IWorkoutGroup } from './models/workout-group.model';
+import { IWorkoutExercise } from './models/workout-exercise.model';
+import { IExercise } from './models/exercise.model';
+import { SkipReason } from '../enum';
+export interface ITemplateSnapshot extends IWorkoutTemplate {
+    sections: ITemplateSnapshotSection[];
+}
+export interface ITemplateSnapshotSection extends IWorkoutSection {
+    groups: ITemplateSnapshotGroup[];
+}
+export interface ITemplateSnapshotGroup extends IWorkoutGroup {
+    exercises: ITemplateSnapshotExercise[];
+}
+export interface ITemplateSnapshotExercise extends IWorkoutExercise {
+    exercise: IExercise;
+}
+export interface IWorkoutSessionSet {
+    workoutSectionId: string;
+    workoutGroupId: string;
+    workoutExerciseId: string;
+    exerciseId: string;
+    setNumber: number;
+    reps?: number | null;
+    weight?: number | null;
+    duration?: number | null;
+    distance?: number | null;
+    calories?: number | null;
+    isSkipped?: boolean;
+    skipReason?: SkipReason | null;
+    skipDetails?: string | null;
+    startedAt?: Date | null;
+    completedAt?: Date | null;
+    notes?: string | null;
+}

package/dist/types/interface/template-snapshot.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -1 +1,2 @@
 export * from './error.utils';
+export * from './workout-template.utils';

package/dist/utils/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./error.utils"), exports);
+__exportStar(require("./workout-template.utils"), exports);

package/dist/utils/workout-template.utils.d.ts

@@ -0,0 +1,51 @@
+import { IWorkoutTemplate, EquipmentType, IWorkoutExercise, ExerciseMeasurementType, WorkoutGroupType } from '../types';
+export interface WorkoutTemplateDurationOptions {
+    averageSetDurationSeconds?: number;
+    averageDistancePaceSecondsPerKm?: number;
+    defaultRestTimeSeconds?: number;
+    defaultSetsPerExercise?: number;
+    transitionTimeMinutes?: number;
+}
+export interface WorkoutExerciseConfig {
+    id?: string;
+    exerciseId: string;
+    plannedReps?: number | null;
+    plannedWeight?: number | null;
+    plannedDuration?: number | null;
+    plannedDistance?: number | null;
+    plannedCalories?: number | null;
+    measurementTypes?: ExerciseMeasurementType[];
+    notes?: string | null;
+    exercise?: {
+        measurementTypes?: ExerciseMeasurementType[];
+    };
+}
+export interface WorkoutGroupConfig {
+    id?: string;
+    name?: string | null;
+    plannedSets: number;
+    plannedRestTime?: number | null;
+    type?: WorkoutGroupType;
+    timeCap?: number | null;
+    intervalSeconds?: number | null;
+    exercises: WorkoutExerciseConfig[];
+}
+export interface WorkoutSectionConfig {
+    id?: string;
+    name: string;
+    description?: string | null;
+    groups?: WorkoutGroupConfig[];
+}
+export declare function calculateExerciseDuration(exercise: WorkoutExerciseConfig | IWorkoutExercise, options?: WorkoutTemplateDurationOptions, sets?: number | null): number;
+export declare function calculateGroupDuration(group: WorkoutGroupConfig, options?: WorkoutTemplateDurationOptions): number;
+export declare function calculateSectionDuration(section: WorkoutSectionConfig, options?: WorkoutTemplateDurationOptions): number;
+export declare function calculateWorkoutTemplateDuration(workoutTemplate: IWorkoutTemplate | null | undefined, options?: WorkoutTemplateDurationOptions): number;
+export declare function formatDuration(totalSeconds: number, options?: {
+    showSeconds?: boolean;
+    roundToMinutes?: boolean;
+}): string;
+export declare function calculateWorkoutTemplateIntensity(workoutTemplate: IWorkoutTemplate | null | undefined): 'light' | 'moderate' | 'high';
+export declare function extractWorkoutTemplateEquipment(workoutTemplate: IWorkoutTemplate | null | undefined): (EquipmentType | null)[];
+export declare function filterEmptyGroups(sections?: WorkoutSectionConfig[]): WorkoutSectionConfig[];
+export declare function getAllWorkoutExercises(workoutTemplate: IWorkoutTemplate | null | undefined): IWorkoutExercise[];
+export declare function getWorkoutExerciseCount(workoutTemplate: IWorkoutTemplate | null | undefined): number;

package/dist/utils/workout-template.utils.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkoutExerciseCount = exports.getAllWorkoutExercises = exports.filterEmptyGroups = exports.extractWorkoutTemplateEquipment = exports.calculateWorkoutTemplateIntensity = exports.formatDuration = exports.calculateWorkoutTemplateDuration = exports.calculateSectionDuration = exports.calculateGroupDuration = exports.calculateExerciseDuration = void 0;
+const types_1 = require("../types");
+const DEFAULT_OPTIONS = {
+    averageSetDurationSeconds: 60,
+    averageDistancePaceSecondsPerKm: 300,
+    defaultRestTimeSeconds: 60,
+    defaultSetsPerExercise: 3,
+    transitionTimeMinutes: 5,
+};
+function roundUpToMultipleOf5(value) {
+    return Math.ceil(value / 5) * 5;
+}
+function calculateExerciseDuration(exercise, options = {}, sets) {
+    var _a;
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const effectiveSets = sets || opts.defaultSetsPerExercise;
+    const measurementTypes = 'measurementTypes' in exercise && exercise.measurementTypes
+        ? exercise.measurementTypes
+        : 'exercise' in exercise && ((_a = exercise.exercise) === null || _a === void 0 ? void 0 : _a.measurementTypes)
+            ? exercise.exercise.measurementTypes
+            : [types_1.ExerciseMeasurementType.REPS];
+    let primaryType = types_1.ExerciseMeasurementType.REPS;
+    if (measurementTypes.includes(types_1.ExerciseMeasurementType.TIME)) {
+        primaryType = types_1.ExerciseMeasurementType.TIME;
+    }
+    else if (measurementTypes.includes(types_1.ExerciseMeasurementType.DISTANCE)) {
+        primaryType = types_1.ExerciseMeasurementType.DISTANCE;
+    }
+    else if (measurementTypes.includes(types_1.ExerciseMeasurementType.CALORIES)) {
+        primaryType = types_1.ExerciseMeasurementType.CALORIES;
+    }
+    let setDuration;
+    switch (primaryType) {
+        case types_1.ExerciseMeasurementType.TIME:
+            const duration = 'plannedDuration' in exercise ? exercise.plannedDuration : null;
+            setDuration = duration && duration > 0 ? duration : opts.averageSetDurationSeconds;
+            break;
+        case types_1.ExerciseMeasurementType.DISTANCE:
+            const distance = 'plannedDistance' in exercise ? exercise.plannedDistance : null;
+            setDuration =
+                distance && distance > 0
+                    ? distance * opts.averageDistancePaceSecondsPerKm
+                    : opts.averageDistancePaceSecondsPerKm;
+            break;
+        case types_1.ExerciseMeasurementType.CALORIES:
+            const calories = 'plannedCalories' in exercise ? exercise.plannedCalories : null;
+            setDuration = calories && calories > 0 ? calories * 6 : opts.averageSetDurationSeconds;
+            break;
+        case types_1.ExerciseMeasurementType.REPS:
+        default:
+            setDuration = opts.averageSetDurationSeconds;
+            break;
+    }
+    const totalSetTime = effectiveSets * setDuration;
+    const restBetweenSets = effectiveSets > 1 ? (effectiveSets - 1) * opts.defaultRestTimeSeconds : 0;
+    return totalSetTime + restBetweenSets;
+}
+exports.calculateExerciseDuration = calculateExerciseDuration;
+function calculateGroupDuration(group, options = {}) {
+    if (!group.exercises || group.exercises.length === 0) {
+        return 0;
+    }
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const groupType = group.type || types_1.WorkoutGroupType.SUPERSET;
+    if (groupType === types_1.WorkoutGroupType.AMRAP) {
+        if (group.timeCap && group.timeCap > 0) {
+            return group.timeCap;
+        }
+    }
+    if (groupType === types_1.WorkoutGroupType.EMOM) {
+        if (group.timeCap && group.timeCap > 0) {
+            return group.timeCap;
+        }
+        const interval = group.intervalSeconds || 60;
+        const rounds = group.plannedSets || opts.defaultSetsPerExercise;
+        return rounds * interval;
+    }
+    const groupSets = group.plannedSets || opts.defaultSetsPerExercise;
+    if (group.exercises.length === 1) {
+        const exercise = group.exercises[0];
+        const exerciseDuration = calculateExerciseDuration(exercise, options, groupSets);
+        if (group.plannedRestTime) {
+            const defaultRestAdded = groupSets > 1 ? (groupSets - 1) * opts.defaultRestTimeSeconds : 0;
+            const groupRest = groupSets > 1 ? (groupSets - 1) * group.plannedRestTime : 0;
+            return exerciseDuration - defaultRestAdded + groupRest;
+        }
+        return exerciseDuration;
+    }
+    const maxSets = groupSets;
+    const oneRoundTime = group.exercises.reduce((total, exercise) => {
+        var _a;
+        const measurementTypes = 'measurementTypes' in exercise && exercise.measurementTypes
+            ? exercise.measurementTypes
+            : 'exercise' in exercise && ((_a = exercise.exercise) === null || _a === void 0 ? void 0 : _a.measurementTypes)
+                ? exercise.exercise.measurementTypes
+                : [types_1.ExerciseMeasurementType.REPS];
+        let primaryType = types_1.ExerciseMeasurementType.REPS;
+        if (measurementTypes.includes(types_1.ExerciseMeasurementType.TIME)) {
+            primaryType = types_1.ExerciseMeasurementType.TIME;
+        }
+        else if (measurementTypes.includes(types_1.ExerciseMeasurementType.DISTANCE)) {
+            primaryType = types_1.ExerciseMeasurementType.DISTANCE;
+        }
+        else if (measurementTypes.includes(types_1.ExerciseMeasurementType.CALORIES)) {
+            primaryType = types_1.ExerciseMeasurementType.CALORIES;
+        }
+        let setDuration;
+        switch (primaryType) {
+            case types_1.ExerciseMeasurementType.TIME:
+                const duration = 'plannedDuration' in exercise ? exercise.plannedDuration : null;
+                setDuration = duration && duration > 0 ? duration : opts.averageSetDurationSeconds;
+                break;
+            case types_1.ExerciseMeasurementType.DISTANCE:
+                const distance = 'plannedDistance' in exercise ? exercise.plannedDistance : null;
+                setDuration =
+                    distance && distance > 0
+                        ? distance * opts.averageDistancePaceSecondsPerKm
+                        : opts.averageDistancePaceSecondsPerKm;
+                break;
+            case types_1.ExerciseMeasurementType.CALORIES:
+                const calories = 'plannedCalories' in exercise ? exercise.plannedCalories : null;
+                setDuration = calories && calories > 0 ? calories * 6 : opts.averageSetDurationSeconds;
+                break;
+            default:
+                setDuration = opts.averageSetDurationSeconds;
+        }
+        return total + setDuration;
+    }, 0);
+    const restTime = group.plannedRestTime || opts.defaultRestTimeSeconds;
+    const totalRoundsTime = maxSets * oneRoundTime;
+    const totalRestTime = maxSets > 1 ? (maxSets - 1) * restTime : 0;
+    return totalRoundsTime + totalRestTime;
+}
+exports.calculateGroupDuration = calculateGroupDuration;
+function calculateSectionDuration(section, options = {}) {
+    if (!section.groups || section.groups.length === 0) {
+        return 0;
+    }
+    return section.groups.reduce((totalSeconds, group) => {
+        if (group.exercises && group.exercises.length > 0) {
+            return totalSeconds + calculateGroupDuration(group, options);
+        }
+        return totalSeconds;
+    }, 0);
+}
+exports.calculateSectionDuration = calculateSectionDuration;
+function calculateWorkoutTemplateDuration(workoutTemplate, options = {}) {
+    if (!workoutTemplate) {
+        return 0;
+    }
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    if (!workoutTemplate.workoutSections || workoutTemplate.workoutSections.length === 0) {
+        return 0;
+    }
+    let totalSeconds = opts.transitionTimeMinutes * 60;
+    workoutTemplate.workoutSections.forEach((section) => {
+        if (section.workoutGroups && section.workoutGroups.length > 0) {
+            section.workoutGroups.forEach((group) => {
+                if (group.workoutExercises && group.workoutExercises.length > 0) {
+                    const groupConfig = {
+                        plannedSets: group.plannedSets,
+                        plannedRestTime: group.plannedRestTime,
+                        type: group.type,
+                        timeCap: group.timeCap,
+                        intervalSeconds: group.intervalSeconds,
+                        exercises: group.workoutExercises.map((we) => ({
+                            exerciseId: we.exerciseId,
+                            plannedReps: we.plannedReps,
+                            plannedWeight: we.plannedWeight,
+                            plannedDuration: we.plannedDuration,
+                            plannedDistance: we.plannedDistance,
+                            plannedCalories: we.plannedCalories,
+                            notes: we.notes,
+                            exercise: we.exercise,
+                        })),
+                    };
+                    totalSeconds += calculateGroupDuration(groupConfig, options);
+                }
+            });
+        }
+    });
+    return roundUpToMultipleOf5(Math.ceil(totalSeconds / 60));
+}
+exports.calculateWorkoutTemplateDuration = calculateWorkoutTemplateDuration;
+function formatDuration(totalSeconds, options) {
+    var _a, _b;
+    const showSeconds = (_a = options === null || options === void 0 ? void 0 : options.showSeconds) !== null && _a !== void 0 ? _a : true;
+    const roundToMinutes = (_b = options === null || options === void 0 ? void 0 : options.roundToMinutes) !== null && _b !== void 0 ? _b : false;
+    if (roundToMinutes) {
+        const minutes = Math.round(totalSeconds / 60);
+        if (minutes < 60) {
+            return `${minutes}min`;
+        }
+        const hours = Math.floor(minutes / 60);
+        const mins = minutes % 60;
+        return mins > 0 ? `${hours}h ${mins}min` : `${hours}h`;
+    }
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (!showSeconds) {
+        const totalMinutes = Math.round(totalSeconds / 60);
+        if (totalMinutes < 60) {
+            return `${totalMinutes}min`;
+        }
+        const h = Math.floor(totalMinutes / 60);
+        const m = totalMinutes % 60;
+        return m > 0 ? `${h}h ${m}min` : `${h}h`;
+    }
+    if (hours > 0) {
+        if (minutes > 0 && seconds > 0) {
+            return `${hours}h ${minutes}min ${seconds}s`;
+        }
+        if (minutes > 0) {
+            return `${hours}h ${minutes}min`;
+        }
+        if (seconds > 0) {
+            return `${hours}h ${seconds}s`;
+        }
+        return `${hours}h`;
+    }
+    if (minutes > 0) {
+        return seconds > 0 ? `${minutes}min ${seconds}s` : `${minutes}min`;
+    }
+    return `${seconds}s`;
+}
+exports.formatDuration = formatDuration;
+function calculateWorkoutTemplateIntensity(workoutTemplate) {
+    if (!workoutTemplate) {
+        return 'moderate';
+    }
+    let totalSets = 0;
+    if (!workoutTemplate.workoutSections || workoutTemplate.workoutSections.length === 0) {
+        return 'light';
+    }
+    workoutTemplate.workoutSections.forEach((section) => {
+        if (section.workoutGroups && section.workoutGroups.length > 0) {
+            section.workoutGroups.forEach((group) => {
+                totalSets += group.plannedSets;
+            });
+        }
+    });
+    if (totalSets > 25) {
+        return 'high';
+    }
+    if (totalSets > 15) {
+        return 'moderate';
+    }
+    return 'light';
+}
+exports.calculateWorkoutTemplateIntensity = calculateWorkoutTemplateIntensity;
+function extractWorkoutTemplateEquipment(workoutTemplate) {
+    if (!workoutTemplate) {
+        return [];
+    }
+    const equipment = [];
+    if (!workoutTemplate.workoutSections || workoutTemplate.workoutSections.length === 0) {
+        return [];
+    }
+    workoutTemplate.workoutSections.forEach((section) => {
+        if (section.workoutGroups && section.workoutGroups.length > 0) {
+            section.workoutGroups.forEach((group) => {
+                if (group.workoutExercises && group.workoutExercises.length > 0) {
+                    group.workoutExercises.forEach((workoutExercise) => {
+                        var _a;
+                        const eq = ((_a = workoutExercise.exercise) === null || _a === void 0 ? void 0 : _a.requiredEquipment) || null;
+                        if (eq !== null) {
+                            equipment.push(eq);
+                        }
+                    });
+                }
+            });
+        }
+    });
+    return Array.from(new Set(equipment));
+}
+exports.extractWorkoutTemplateEquipment = extractWorkoutTemplateEquipment;
+function filterEmptyGroups(sections) {
+    if (!sections || sections.length === 0) {
+        return [];
+    }
+    return sections
+        .map((section) => {
+        var _a;
+        return ({
+            ...section,
+            groups: (_a = section.groups) === null || _a === void 0 ? void 0 : _a.filter((group) => group.exercises && group.exercises.length > 0),
+        });
+    })
+        .filter((section) => section.groups && section.groups.length > 0);
+}
+exports.filterEmptyGroups = filterEmptyGroups;
+function getAllWorkoutExercises(workoutTemplate) {
+    if (!workoutTemplate) {
+        return [];
+    }
+    if (workoutTemplate.workoutSections && workoutTemplate.workoutSections.length > 0) {
+        const exercises = [];
+        workoutTemplate.workoutSections.forEach((section) => {
+            if (section.workoutGroups && section.workoutGroups.length > 0) {
+                section.workoutGroups.forEach((group) => {
+                    if (group.workoutExercises && group.workoutExercises.length > 0) {
+                        exercises.push(...group.workoutExercises);
+                    }
+                });
+            }
+        });
+        return exercises;
+    }
+    return [];
+}
+exports.getAllWorkoutExercises = getAllWorkoutExercises;
+function getWorkoutExerciseCount(workoutTemplate) {
+    return getAllWorkoutExercises(workoutTemplate).length;
+}
+exports.getWorkoutExerciseCount = getWorkoutExerciseCount;