@aneuhold/core-ts-db-lib 4.0.3 → 4.1.0

package/lib/services/workout/Exercise/WorkoutExerciseService.ts

@@ -0,0 +1,173 @@
+import type { WorkoutEquipmentType } from '../../../documents/workout/WorkoutEquipmentType.js';
+import type { WorkoutExercise } from '../../../documents/workout/WorkoutExercise.js';
+import {
+  ExerciseProgressionType,
+  ExerciseRepRange
+} from '../../../documents/workout/WorkoutExercise.js';
+import type { WorkoutExerciseCalibration } from '../../../documents/workout/WorkoutExerciseCalibration.js';
+import WorkoutEquipmentTypeService from '../EquipmentType/WorkoutEquipmentTypeService.js';
+import WorkoutExerciseCalibrationService from '../ExerciseCalibration/WorkoutExerciseCalibrationService.js';
+import WorkoutSFRService from '../util/SFR/WorkoutSFRService.js';
+
+/**
+ * A service for handling operations related to {@link WorkoutExercise}s.
+ */
+export default class WorkoutExerciseService {
+  /**
+   * Returns the numeric rep range based on the ExerciseRepRange enum.
+   *
+   * - Heavy: { min: 5, max: 15 }
+   * - Medium: { min: 10, max: 20 }
+   * - Light: { min: 15, max: 30 }
+   *
+   * @param repRange The exercise rep range.
+   */
+  static getRepRangeValues(repRange: ExerciseRepRange): { min: number; max: number } {
+    switch (repRange) {
+      case ExerciseRepRange.Heavy:
+        return { min: 5, max: 15 };
+      case ExerciseRepRange.Medium:
+        return { min: 10, max: 20 };
+      case ExerciseRepRange.Light:
+        return { min: 15, max: 30 };
+    }
+  }
+
+  /**
+   * Gets the fatigue score for an exercise.
+   *
+   * @param exercise The exercise to get the fatigue score for.
+   */
+  static getFatigueScore(exercise: WorkoutExercise): number {
+    return WorkoutSFRService.getFatigueTotal(exercise.initialFatigueGuess) || 0;
+  }
+
+  /**
+   * Calculates the progressed target weight and reps for an exercise based on microcycle progression.
+   * This returns the target weight and reps for the FIRST set of the exercise in the given microcycle,
+   * assuming it is an accumulation phase (i.e., not a deload).
+   *
+   * This method applies either rep-based or load-based progression depending on the exercise's
+   * preferred progression type, then rounds the weight to available equipment options.
+   *
+   * Rep progression: The weight is calculated based on reps at microcycle 0, and reps increase
+   * by 2 per microcycle to reach max reps at the final accumulation microcycle (ideally),
+   * or drop back down and increase weight by 2%.
+   *
+   * Load progression: Increases weight by at least 2% per microcycle.
+   * If weight can't be increased, adds 2 reps instead.
+   */
+  static calculateTargetRepsAndWeightForFirstSet(params: {
+    exercise: WorkoutExercise;
+    calibration: WorkoutExerciseCalibration;
+    equipment: WorkoutEquipmentType;
+    microcycleIndex: number;
+    firstMicrocycleRir: number;
+  }): { targetWeight: number; targetReps: number } {
+    const { exercise, calibration, equipment, microcycleIndex, firstMicrocycleRir } = params;
+
+    // Validate equipment has weight options
+    if (!equipment.weightOptions || equipment.weightOptions.length === 0) {
+      throw new Error(
+        `No weight options defined for equipment type ${equipment._id}, ${equipment.title}`
+      );
+    }
+
+    // Get rep range for this exercise
+    const repRange = this.getRepRangeValues(exercise.repRange);
+    const repRangeMidpoint = Math.floor((repRange.min + repRange.max) / 2);
+
+    // For rep progression, calculate weight based on reps at microcycle 0
+    // For load progression, use max reps
+    let baseRepsForWeight: number;
+    if (exercise.preferredProgressionType === ExerciseProgressionType.Rep) {
+      baseRepsForWeight = repRangeMidpoint + firstMicrocycleRir;
+    } else {
+      // Load progression uses max reps for initial weight calculation
+      baseRepsForWeight = repRange.max;
+    }
+
+    // Calculate base weight
+    let targetWeight = WorkoutExerciseCalibrationService.getTargetWeight(
+      calibration,
+      baseRepsForWeight
+    );
+
+    // Round to nearest available weight, preferring lower
+    const roundedWeight = WorkoutEquipmentTypeService.findNearestWeight(
+      equipment,
+      targetWeight,
+      'prefer-down'
+    );
+    if (roundedWeight === null) {
+      throw new Error(
+        `No available weight options found for equipment type ${equipment._id}, ${equipment.title}`
+      );
+    }
+    targetWeight = roundedWeight;
+
+    // Calculate target reps based on progression type
+    let targetReps: number;
+    if (exercise.preferredProgressionType === ExerciseProgressionType.Rep) {
+      // Rep progression: Add up to max reps, then loop back if needed
+      let currentMicrocycleIndex = 0;
+      targetReps = repRangeMidpoint;
+
+      while (currentMicrocycleIndex < microcycleIndex) {
+        targetReps += 2;
+        if (targetReps > repRange.max) {
+          // Different reset amounts based on the rep range
+          switch (exercise.repRange) {
+            case ExerciseRepRange.Heavy:
+              targetReps = targetReps - 4;
+              break;
+            case ExerciseRepRange.Medium:
+              targetReps = targetReps - 6;
+              break;
+            case ExerciseRepRange.Light:
+              targetReps = targetReps - 8;
+              break;
+          }
+          const nextWeight = this.findNextTwoPercentWeight(targetWeight, equipment);
+          if (nextWeight !== null) {
+            targetWeight = nextWeight;
+          }
+        }
+        currentMicrocycleIndex++;
+      }
+    } else {
+      // Load progression: Start at max reps
+      targetReps = repRange.max;
+    }
+
+    // Apply load progression if applicable for the weight
+    if (exercise.preferredProgressionType === ExerciseProgressionType.Load && microcycleIndex > 0) {
+      const nextWeight = this.findNextTwoPercentWeight(targetWeight, equipment);
+      if (nextWeight !== null) {
+        targetWeight = nextWeight;
+      } else {
+        // Increase reps if we can't increase weight
+        targetReps = targetReps + 2;
+      }
+    }
+
+    return { targetWeight, targetReps };
+  }
+
+  private static findNextTwoPercentWeight(
+    currentWeight: number,
+    equipment: WorkoutEquipmentType
+  ): number | null {
+    // Increase weight by at least 2%
+    const twoPercentIncrease = currentWeight * 1.02;
+
+    // Find the smallest weight >= 2% increase (This is purposefully done from the rounded weight
+    // because the rounded weight will be what the user would have actually lifted previously)
+    const nextWeight = WorkoutEquipmentTypeService.findNearestWeight(
+      equipment,
+      twoPercentIncrease,
+      'up'
+    );
+    return nextWeight;
+  }
+}

package/lib/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.d.ts

@@ -0,0 +1,35 @@
+import type { WorkoutExerciseCalibration } from '../../../documents/workout/WorkoutExerciseCalibration.js';
+/**
+ * A service for handling operations related to {@link WorkoutExerciseCalibration}s.
+ */
+export default class WorkoutExerciseCalibrationService {
+    /**
+     * Calculates the 1 Rep Max using the NASM formula.
+     *
+     * Formula: (Weight Lifted × Reps / 30.48) + Weight Lifted
+     *
+     * @param calibration The workout exercise calibration.
+     */
+    static get1RM(calibration: WorkoutExerciseCalibration): number;
+    /**
+     * Calculates the target weight for a set based on target reps and 1RM.
+     *
+     * Returns the calculated weight without rounding. Consumer can use
+     * WorkoutEquipmentTypeService.findNearestWeight() to round if needed.
+     *
+     * @param calibration The workout exercise calibration.
+     * @param targetReps The target number of reps.
+     */
+    static getTargetWeight(calibration: WorkoutExerciseCalibration, targetReps: number): number;
+    /**
+     * Calculates the target percentage of 1RM for a given target rep count.
+     *
+     * Uses the formula: targetPercentage = 30 + ((targetReps - 5) * 2.2)
+     *
+     * This ensures training stays within the 30%-85% 1RM range (30 reps to 5 reps).
+     *
+     * @param targetReps The target number of reps.
+     */
+    private static getTargetPercentage;
+}
+//# sourceMappingURL=WorkoutExerciseCalibrationService.d.ts.map

package/lib/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkoutExerciseCalibrationService.d.ts","sourceRoot":"","sources":["../../../../src/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0DAA0D,CAAC;AAE3G;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iCAAiC;IACpD;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,0BAA0B,GAAG,MAAM;IAI9D;;;;;;;;OAQG;IACH,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,0BAA0B,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAM3F;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAGnC"}

package/lib/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.js

@@ -0,0 +1,42 @@
+/**
+ * A service for handling operations related to {@link WorkoutExerciseCalibration}s.
+ */
+export default class WorkoutExerciseCalibrationService {
+    /**
+     * Calculates the 1 Rep Max using the NASM formula.
+     *
+     * Formula: (Weight Lifted × Reps / 30.48) + Weight Lifted
+     *
+     * @param calibration The workout exercise calibration.
+     */
+    static get1RM(calibration) {
+        return (calibration.weight * calibration.reps) / 30.48 + calibration.weight;
+    }
+    /**
+     * Calculates the target weight for a set based on target reps and 1RM.
+     *
+     * Returns the calculated weight without rounding. Consumer can use
+     * WorkoutEquipmentTypeService.findNearestWeight() to round if needed.
+     *
+     * @param calibration The workout exercise calibration.
+     * @param targetReps The target number of reps.
+     */
+    static getTargetWeight(calibration, targetReps) {
+        const oneRepMax = this.get1RM(calibration);
+        const targetPercentage = this.getTargetPercentage(targetReps);
+        return (targetPercentage / 100) * oneRepMax;
+    }
+    /**
+     * Calculates the target percentage of 1RM for a given target rep count.
+     *
+     * Uses the formula: targetPercentage = 30 + ((targetReps - 5) * 2.2)
+     *
+     * This ensures training stays within the 30%-85% 1RM range (30 reps to 5 reps).
+     *
+     * @param targetReps The target number of reps.
+     */
+    static getTargetPercentage(targetReps) {
+        return 30 + (targetReps - 5) * 2.2;
+    }
+}
+//# sourceMappingURL=WorkoutExerciseCalibrationService.js.map

package/lib/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkoutExerciseCalibrationService.js","sourceRoot":"","sources":["../../../../src/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iCAAiC;IACpD;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CAAC,WAAuC;QACnD,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC;IAC9E,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,eAAe,CAAC,WAAuC,EAAE,UAAkB;QAChF,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC3C,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;QAC9D,OAAO,CAAC,gBAAgB,GAAG,GAAG,CAAC,GAAG,SAAS,CAAC;IAC9C,CAAC;IAED;;;;;;;;OAQG;IACK,MAAM,CAAC,mBAAmB,CAAC,UAAkB;QACnD,OAAO,EAAE,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;IACrC,CAAC;CACF"}

package/lib/services/workout/ExerciseCalibration/WorkoutExerciseCalibrationService.ts

@@ -0,0 +1,45 @@
+import type { WorkoutExerciseCalibration } from '../../../documents/workout/WorkoutExerciseCalibration.js';
+
+/**
+ * A service for handling operations related to {@link WorkoutExerciseCalibration}s.
+ */
+export default class WorkoutExerciseCalibrationService {
+  /**
+   * Calculates the 1 Rep Max using the NASM formula.
+   *
+   * Formula: (Weight Lifted × Reps / 30.48) + Weight Lifted
+   *
+   * @param calibration The workout exercise calibration.
+   */
+  static get1RM(calibration: WorkoutExerciseCalibration): number {
+    return (calibration.weight * calibration.reps) / 30.48 + calibration.weight;
+  }
+
+  /**
+   * Calculates the target weight for a set based on target reps and 1RM.
+   *
+   * Returns the calculated weight without rounding. Consumer can use
+   * WorkoutEquipmentTypeService.findNearestWeight() to round if needed.
+   *
+   * @param calibration The workout exercise calibration.
+   * @param targetReps The target number of reps.
+   */
+  static getTargetWeight(calibration: WorkoutExerciseCalibration, targetReps: number): number {
+    const oneRepMax = this.get1RM(calibration);
+    const targetPercentage = this.getTargetPercentage(targetReps);
+    return (targetPercentage / 100) * oneRepMax;
+  }
+
+  /**
+   * Calculates the target percentage of 1RM for a given target rep count.
+   *
+   * Uses the formula: targetPercentage = 30 + ((targetReps - 5) * 2.2)
+   *
+   * This ensures training stays within the 30%-85% 1RM range (30 reps to 5 reps).
+   *
+   * @param targetReps The target number of reps.
+   */
+  private static getTargetPercentage(targetReps: number): number {
+    return 30 + (targetReps - 5) * 2.2;
+  }
+}

package/lib/services/workout/Mesocycle/WorkoutMesocyclePlanContext.d.ts

@@ -0,0 +1,90 @@
+import type { UUID } from 'crypto';
+import type { WorkoutEquipmentType } from '../../../documents/workout/WorkoutEquipmentType.js';
+import type { WorkoutExercise } from '../../../documents/workout/WorkoutExercise.js';
+import type { CalibrationExercisePair, WorkoutExerciseCalibration } from '../../../documents/workout/WorkoutExerciseCalibration.js';
+import type { WorkoutMesocycle } from '../../../documents/workout/WorkoutMesocycle.js';
+import type { WorkoutMicrocycle } from '../../../documents/workout/WorkoutMicrocycle.js';
+import type { WorkoutSession } from '../../../documents/workout/WorkoutSession.js';
+import type { WorkoutSessionExercise } from '../../../documents/workout/WorkoutSessionExercise.js';
+import type { WorkoutSet } from '../../../documents/workout/WorkoutSet.js';
+/**
+ * Central shared context for generating or updating a {@link WorkoutMesocycle}.
+ *
+ * This keeps the generation pipeline (Mesocycle -> Microcycle -> Session -> Set) from needing to
+ * thread the same inputs (mesocycle config + document lookups + optional historical docs) through
+ * every method.
+ */
+export default class WorkoutMesocyclePlanContext {
+    mesocycle: WorkoutMesocycle;
+    existingMicrocycles: WorkoutMicrocycle[];
+    existingSessions: WorkoutSession[];
+    existingSessionExercises: WorkoutSessionExercise[];
+    existingSets: WorkoutSet[];
+    /**
+     * A constant for now that defines what the target RIR is for the first microcycle of every mesocycle,
+     * regardless of anything else.
+     */
+    readonly FIRST_MICROCYCLE_RIR = 4;
+    readonly calibrationMap: Map<UUID, WorkoutExerciseCalibration>;
+    readonly exerciseMap: Map<UUID, WorkoutExercise>;
+    readonly equipmentMap: Map<UUID, WorkoutEquipmentType>;
+    readonly sessionMap: Map<UUID, WorkoutSession>;
+    readonly sessionExerciseMap: Map<UUID, WorkoutSessionExercise>;
+    readonly microcyclesToCreate: WorkoutMicrocycle[];
+    /**
+     * All microcycles for this mesocycle in chronological order.
+     *
+     * This includes any existing microcycles (filtered to the target mesocycle) and
+     * all newly generated microcycles.
+     */
+    readonly microcyclesInOrder: WorkoutMicrocycle[];
+    readonly sessionsToCreate: WorkoutSession[];
+    readonly sessionExercisesToCreate: WorkoutSessionExercise[];
+    readonly setsToCreate: WorkoutSet[];
+    /**
+     * The array of sessions corresponding to the array of calibration exercise pairs, in order,
+     * for that session.
+     */
+    plannedSessionExercisePairs: CalibrationExercisePair[][] | undefined;
+    /**
+     * Stores the mesocycle's muscle-group-wide exercise ordering.
+     *
+     * This is used by session generation to distribute set progression evenly across
+     * exercises that share a primary muscle group, regardless of which session they
+     * ended up in.
+     */
+    muscleGroupToExercisePairsMap: Map<UUID, CalibrationExercisePair[]> | undefined;
+    exerciseIdToSessionIndex: Map<UUID, number> | undefined;
+    /**
+     * Creates a new workout mesocycle planning context.
+     */
+    constructor(mesocycle: WorkoutMesocycle, calibrations: WorkoutExerciseCalibration[], exercises: WorkoutExercise[], equipmentTypes: WorkoutEquipmentType[], existingMicrocycles?: WorkoutMicrocycle[], existingSessions?: WorkoutSession[], existingSessionExercises?: WorkoutSessionExercise[], existingSets?: WorkoutSet[]);
+    /**
+     * Adds a microcycle to the list of microcycles to create and the overall chronological list.
+     */
+    addMicrocycle(toCreate: WorkoutMicrocycle): void;
+    /**
+     * Adds a session to the context and updates internal maps.
+     */
+    addSession(session: WorkoutSession): void;
+    /**
+     * Adds a session exercise to the context and updates internal maps.
+     */
+    addSessionExercise(sessionExercise: WorkoutSessionExercise): void;
+    /**
+     * Stores the planned session -> exercises structure for the mesocycle and derives
+     * the muscle-group-wide ordering used for set progression.
+     */
+    setPlannedSessionExercisePairs(plannedSessionExercisePairs: CalibrationExercisePair[][]): void;
+    /**
+     * Builds and stores a map of primary muscle group -> ordered exercise pairs for the mesocycle plan.
+     *
+     * Also builds a map of exercise ID -> session index for use during session generation.
+     *
+     * The ordering is determined by flattening the planned sessions in order, then the exercises within
+     * each session in order. This allows set progression to be distributed evenly across a muscle group
+     * for the entire microcycle, even when exercises are split across sessions.
+     */
+    private buildSessionPairsMaps;
+}
+//# sourceMappingURL=WorkoutMesocyclePlanContext.d.ts.map

package/lib/services/workout/Mesocycle/WorkoutMesocyclePlanContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkoutMesocyclePlanContext.d.ts","sourceRoot":"","sources":["../../../../src/services/workout/Mesocycle/WorkoutMesocyclePlanContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAC;AAC/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+CAA+C,CAAC;AACrF,OAAO,KAAK,EACV,uBAAuB,EACvB,0BAA0B,EAC3B,MAAM,0DAA0D,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AACvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AACnG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,2BAA2B;IA4CrC,SAAS,EAAE,gBAAgB;IAI3B,mBAAmB,EAAE,iBAAiB,EAAE;IACxC,gBAAgB,EAAE,cAAc,EAAE;IAClC,wBAAwB,EAAE,sBAAsB,EAAE;IAClD,YAAY,EAAE,UAAU,EAAE;IAlDnC;;;OAGG;IACH,SAAgB,oBAAoB,KAAK;IAEzC,SAAgB,cAAc,EAAE,GAAG,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAC;IACtE,SAAgB,WAAW,EAAE,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IACxD,SAAgB,YAAY,EAAE,GAAG,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;IAC9D,SAAgB,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;IACtD,SAAgB,kBAAkB,EAAE,GAAG,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAC;IAEtE,SAAgB,mBAAmB,EAAE,iBAAiB,EAAE,CAAM;IAC9D;;;;;OAKG;IACH,SAAgB,kBAAkB,EAAE,iBAAiB,EAAE,CAAM;IAC7D,SAAgB,gBAAgB,EAAE,cAAc,EAAE,CAAM;IACxD,SAAgB,wBAAwB,EAAE,sBAAsB,EAAE,CAAM;IACxE,SAAgB,YAAY,EAAE,UAAU,EAAE,CAAM;IAEhD;;;OAGG;IACI,2BAA2B,EAAE,uBAAuB,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5E;;;;;;OAMG;IACI,6BAA6B,EAAE,GAAG,CAAC,IAAI,EAAE,uBAAuB,EAAE,CAAC,GAAG,SAAS,CAAC;IAChF,wBAAwB,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAE/D;;OAEG;gBAEM,SAAS,EAAE,gBAAgB,EAClC,YAAY,EAAE,0BAA0B,EAAE,EAC1C,SAAS,EAAE,eAAe,EAAE,EAC5B,cAAc,EAAE,oBAAoB,EAAE,EAC/B,mBAAmB,GAAE,iBAAiB,EAAO,EAC7C,gBAAgB,GAAE,cAAc,EAAO,EACvC,wBAAwB,GAAE,sBAAsB,EAAO,EACvD,YAAY,GAAE,UAAU,EAAO;IAcxC;;OAEG;IACI,aAAa,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAKvD;;OAEG;IACI,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAKhD;;OAEG;IACI,kBAAkB,CAAC,eAAe,EAAE,sBAAsB,GAAG,IAAI;IAKxE;;;OAGG;IACI,8BAA8B,CACnC,2BAA2B,EAAE,uBAAuB,EAAE,EAAE,GACvD,IAAI;IAKP;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;CA6B9B"}

package/lib/services/workout/Mesocycle/WorkoutMesocyclePlanContext.js

@@ -0,0 +1,131 @@
+/**
+ * Central shared context for generating or updating a {@link WorkoutMesocycle}.
+ *
+ * This keeps the generation pipeline (Mesocycle -> Microcycle -> Session -> Set) from needing to
+ * thread the same inputs (mesocycle config + document lookups + optional historical docs) through
+ * every method.
+ */
+export default class WorkoutMesocyclePlanContext {
+    mesocycle;
+    existingMicrocycles;
+    existingSessions;
+    existingSessionExercises;
+    existingSets;
+    /**
+     * A constant for now that defines what the target RIR is for the first microcycle of every mesocycle,
+     * regardless of anything else.
+     */
+    FIRST_MICROCYCLE_RIR = 4;
+    calibrationMap;
+    exerciseMap;
+    equipmentMap;
+    sessionMap;
+    sessionExerciseMap;
+    microcyclesToCreate = [];
+    /**
+     * All microcycles for this mesocycle in chronological order.
+     *
+     * This includes any existing microcycles (filtered to the target mesocycle) and
+     * all newly generated microcycles.
+     */
+    microcyclesInOrder = [];
+    sessionsToCreate = [];
+    sessionExercisesToCreate = [];
+    setsToCreate = [];
+    /**
+     * The array of sessions corresponding to the array of calibration exercise pairs, in order,
+     * for that session.
+     */
+    plannedSessionExercisePairs;
+    /**
+     * Stores the mesocycle's muscle-group-wide exercise ordering.
+     *
+     * This is used by session generation to distribute set progression evenly across
+     * exercises that share a primary muscle group, regardless of which session they
+     * ended up in.
+     */
+    muscleGroupToExercisePairsMap;
+    exerciseIdToSessionIndex;
+    /**
+     * Creates a new workout mesocycle planning context.
+     */
+    constructor(mesocycle, calibrations, exercises, equipmentTypes, existingMicrocycles = [], existingSessions = [], existingSessionExercises = [], existingSets = []) {
+        this.mesocycle = mesocycle;
+        this.existingMicrocycles = existingMicrocycles;
+        this.existingSessions = existingSessions;
+        this.existingSessionExercises = existingSessionExercises;
+        this.existingSets = existingSets;
+        this.calibrationMap = new Map(calibrations.map((c) => [c._id, c]));
+        this.exerciseMap = new Map(exercises.map((e) => [e._id, e]));
+        this.equipmentMap = new Map(equipmentTypes.map((et) => [et._id, et]));
+        this.sessionMap = new Map(existingSessions.map((s) => [s._id, s]));
+        this.sessionExerciseMap = new Map(existingSessionExercises.map((s) => [s._id, s]));
+        const existingMicrocyclesForMesocycle = existingMicrocycles
+            .filter((m) => m.workoutMesocycleId === mesocycle._id)
+            .sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+        this.microcyclesInOrder.push(...existingMicrocyclesForMesocycle);
+    }
+    /**
+     * Adds a microcycle to the list of microcycles to create and the overall chronological list.
+     */
+    addMicrocycle(toCreate) {
+        this.microcyclesToCreate.push(toCreate);
+        this.microcyclesInOrder.push(toCreate);
+    }
+    /**
+     * Adds a session to the context and updates internal maps.
+     */
+    addSession(session) {
+        this.sessionsToCreate.push(session);
+        this.sessionMap.set(session._id, session);
+    }
+    /**
+     * Adds a session exercise to the context and updates internal maps.
+     */
+    addSessionExercise(sessionExercise) {
+        this.sessionExercisesToCreate.push(sessionExercise);
+        this.sessionExerciseMap.set(sessionExercise._id, sessionExercise);
+    }
+    /**
+     * Stores the planned session -> exercises structure for the mesocycle and derives
+     * the muscle-group-wide ordering used for set progression.
+     */
+    setPlannedSessionExercisePairs(plannedSessionExercisePairs) {
+        this.plannedSessionExercisePairs = plannedSessionExercisePairs;
+        this.buildSessionPairsMaps(plannedSessionExercisePairs);
+    }
+    /**
+     * Builds and stores a map of primary muscle group -> ordered exercise pairs for the mesocycle plan.
+     *
+     * Also builds a map of exercise ID -> session index for use during session generation.
+     *
+     * The ordering is determined by flattening the planned sessions in order, then the exercises within
+     * each session in order. This allows set progression to be distributed evenly across a muscle group
+     * for the entire microcycle, even when exercises are split across sessions.
+     */
+    buildSessionPairsMaps(sessionsToExercisePairs) {
+        const muscleGroupToPairsMap = new Map();
+        const exerciseIdToSessionIndex = new Map();
+        for (let sessionIndex = 0; sessionIndex < sessionsToExercisePairs.length; sessionIndex++) {
+            const sessionExercisePairs = sessionsToExercisePairs[sessionIndex];
+            for (const exercisePair of sessionExercisePairs) {
+                // Set the session index for this exercise as well
+                exerciseIdToSessionIndex.set(exercisePair.exercise._id, sessionIndex);
+                const primaryMuscleGroupId = exercisePair.exercise.primaryMuscleGroups[0];
+                if (!primaryMuscleGroupId) {
+                    throw new Error(`Exercise ${exercisePair.exercise._id}, ${exercisePair.exercise.exerciseName} has no primary muscle group`);
+                }
+                const existing = muscleGroupToPairsMap.get(primaryMuscleGroupId);
+                if (existing) {
+                    existing.push(exercisePair);
+                }
+                else {
+                    muscleGroupToPairsMap.set(primaryMuscleGroupId, [exercisePair]);
+                }
+            }
+        }
+        this.muscleGroupToExercisePairsMap = muscleGroupToPairsMap;
+        this.exerciseIdToSessionIndex = exerciseIdToSessionIndex;
+    }
+}
+//# sourceMappingURL=WorkoutMesocyclePlanContext.js.map

package/lib/services/workout/Mesocycle/WorkoutMesocyclePlanContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkoutMesocyclePlanContext.js","sourceRoot":"","sources":["../../../../src/services/workout/Mesocycle/WorkoutMesocyclePlanContext.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,2BAA2B;IA4CrC;IAIA;IACA;IACA;IACA;IAlDT;;;OAGG;IACa,oBAAoB,GAAG,CAAC,CAAC;IAEzB,cAAc,CAAwC;IACtD,WAAW,CAA6B;IACxC,YAAY,CAAkC;IAC9C,UAAU,CAA4B;IACtC,kBAAkB,CAAoC;IAEtD,mBAAmB,GAAwB,EAAE,CAAC;IAC9D;;;;;OAKG;IACa,kBAAkB,GAAwB,EAAE,CAAC;IAC7C,gBAAgB,GAAqB,EAAE,CAAC;IACxC,wBAAwB,GAA6B,EAAE,CAAC;IACxD,YAAY,GAAiB,EAAE,CAAC;IAEhD;;;OAGG;IACI,2BAA2B,CAA0C;IAC5E;;;;;;OAMG;IACI,6BAA6B,CAAmD;IAChF,wBAAwB,CAAgC;IAE/D;;OAEG;IACH,YACS,SAA2B,EAClC,YAA0C,EAC1C,SAA4B,EAC5B,cAAsC,EAC/B,sBAA2C,EAAE,EAC7C,mBAAqC,EAAE,EACvC,2BAAqD,EAAE,EACvD,eAA6B,EAAE;QAP/B,cAAS,GAAT,SAAS,CAAkB;QAI3B,wBAAmB,GAAnB,mBAAmB,CAA0B;QAC7C,qBAAgB,GAAhB,gBAAgB,CAAuB;QACvC,6BAAwB,GAAxB,wBAAwB,CAA+B;QACvD,iBAAY,GAAZ,YAAY,CAAmB;QAEtC,IAAI,CAAC,cAAc,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACnE,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7D,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACnE,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnF,MAAM,+BAA+B,GAAG,mBAAmB;aACxD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,kBAAkB,KAAK,SAAS,CAAC,GAAG,CAAC;aACrD,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,+BAA+B,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,QAA2B;QAC9C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,UAAU,CAAC,OAAuB;QACvC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,eAAuC;QAC/D,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACpD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;IACpE,CAAC;IAED;;;OAGG;IACI,8BAA8B,CACnC,2BAAwD;QAExD,IAAI,CAAC,2BAA2B,GAAG,2BAA2B,CAAC;QAC/D,IAAI,CAAC,qBAAqB,CAAC,2BAA2B,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;;;OAQG;IACK,qBAAqB,CAAC,uBAAoD;QAChF,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAmC,CAAC;QACzE,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAAgB,CAAC;QAEzD,KAAK,IAAI,YAAY,GAAG,CAAC,EAAE,YAAY,GAAG,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC;YACzF,MAAM,oBAAoB,GAAG,uBAAuB,CAAC,YAAY,CAAC,CAAC;YACnE,KAAK,MAAM,YAAY,IAAI,oBAAoB,EAAE,CAAC;gBAChD,kDAAkD;gBAClD,wBAAwB,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;gBAEtE,MAAM,oBAAoB,GAAG,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;gBAC1E,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAC1B,MAAM,IAAI,KAAK,CACb,YAAY,YAAY,CAAC,QAAQ,CAAC,GAAG,KAAK,YAAY,CAAC,QAAQ,CAAC,YAAY,8BAA8B,CAC3G,CAAC;gBACJ,CAAC;gBAED,MAAM,QAAQ,GAAG,qBAAqB,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;gBACjE,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAC9B,CAAC;qBAAM,CAAC;oBACN,qBAAqB,CAAC,GAAG,CAAC,oBAAoB,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;gBAClE,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,6BAA6B,GAAG,qBAAqB,CAAC;QAC3D,IAAI,CAAC,wBAAwB,GAAG,wBAAwB,CAAC;IAC3D,CAAC;CACF"}