hevy-shared 1.0.962 → 1.0.964

package/built/normalizedWorkoutUtils.d.ts

@@ -0,0 +1,88 @@
+import { ExerciseType, RPE, SetType, ShareToPlatform, WorkoutBiometrics, WorkoutMedia, WorkoutVisibility } from '.';
+/**
+ * Events are used to determine the start time, end time and duration of a
+ * `NormalizedWorkout`, in a way that can be persisted to disk.
+ */
+export interface NormalizedWorkoutEvent {
+    type: 'resume' | 'pause';
+    unixTimestamp: number;
+}
+/**
+ * NormalizedWorkout describes the state of a workout. It's used when
+ * persisting an ongoing workout to disk, or calculating shareables after
+ * completing the workout.
+ *
+ * The duration of a `NormalizedWorkout` is _derived_ from the `timeEvents`
+ * array.  There is no single "duration" variable, because that would require
+ * pausing to be a complex stateful operation.
+ */
+export interface NormalizedWorkout {
+    name: string;
+    description: string;
+    media: WorkoutMedia[];
+    startTime: number;
+    timeEvents: NormalizedWorkoutEvent[];
+    exercises: NormalizedExercise[];
+    routineId?: string;
+    trackWorkoutAsRoutine: boolean;
+    updateRoutineFromWorkout?: boolean;
+    appleWatch: boolean;
+    wearosWatch: boolean;
+    workoutVisibility: WorkoutVisibility;
+    isWorkoutBiometricsPublic: boolean;
+    shareTo: {
+        [key in ShareToPlatform]: boolean;
+    };
+    clientId: string;
+    biometrics?: WorkoutBiometrics;
+    trainerProgramId: string | undefined;
+}
+export interface NormalizedSet {
+    index: number;
+    indicator: SetType;
+    weight?: number;
+    reps?: number;
+    distance?: number;
+    duration?: number;
+    customMetric?: number;
+    rpe?: RPE;
+    targetRpe?: RPE;
+    completed: boolean;
+    completedAt?: string;
+}
+export interface NormalizedExercise {
+    title: string;
+    exerciseTemplateId: string;
+    supersetId?: number;
+    autoRestTimerSeconds?: number;
+    routineNotes: string;
+    notes: string;
+    volumeDoublingEnabled: boolean;
+    sets: NormalizedSet[];
+}
+export declare const calculateDuration: (normalizedWorkout: Pick<NormalizedWorkout, "startTime" | "timeEvents">, nowUnix: number) => number;
+export declare const calculateEndTime: (normalizedWorkout: Pick<NormalizedWorkout, "startTime" | "timeEvents">, nowUnix: number) => number;
+interface GenerateWorkoutTimeEventsArgs {
+    startTimeUnix: number;
+    durationSeconds: number;
+    nowUnix: number;
+    /**
+     * if this is `true`, generate a pause event at the current timestamp
+     */
+    isPaused?: boolean;
+}
+export declare const generateWorkoutTimeEvents: ({ startTimeUnix, durationSeconds, nowUnix, isPaused, }: GenerateWorkoutTimeEventsArgs) => NormalizedWorkoutEvent[];
+export declare const isWorkoutCurrentlyPaused: (normalizedWorkout: NormalizedWorkout) => boolean;
+/**
+ * When logging a workout, we can't just use the `completed` state of a set to
+ * determine if the user meant for the set to be included in the workout. This
+ * is because a lot of users never mark sets as completed, and forcing them to
+ * do that wouldn't add anything to the app. For that reason, we count a set as
+ * completed if it contains inputted valid values based on its exercise type.
+ * This function filters out all sets in a `NormalizedWorkout` that are
+ * incomplete based on the values inputted.
+ */
+export declare const trimWorkout: (workout: NormalizedWorkout, exerciseTypeMap: {
+    [key: string]: ExerciseType;
+}) => NormalizedWorkout;
+export {};

package/built/normalizedWorkoutUtils.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimWorkout = exports.isWorkoutCurrentlyPaused = exports.generateWorkoutTimeEvents = exports.calculateEndTime = exports.calculateDuration = void 0;
+const _1 = require(".");
+const calculateDuration = (normalizedWorkout, nowUnix) => {
+    const { startTime, timeEvents } = normalizedWorkout;
+    if (!timeEvents.length)
+        return nowUnix - startTime;
+    const timeBeforeFirstEvent = timeEvents[0].unixTimestamp - startTime;
+    const duration = timeEvents.reduce((prev, curr, index, array) => {
+        var _a;
+        const nextEvent = (_a = array[index + 1]) !== null && _a !== void 0 ? _a : {
+            type: 'resume',
+            unixTimestamp: nowUnix,
+        };
+        if (curr.type === 'pause') {
+            return prev;
+        }
+        else {
+            return prev + nextEvent.unixTimestamp - curr.unixTimestamp;
+        }
+    }, timeBeforeFirstEvent);
+    return duration;
+};
+exports.calculateDuration = calculateDuration;
+const calculateEndTime = (normalizedWorkout, nowUnix) => {
+    const { startTime } = normalizedWorkout;
+    const durationSeconds = (0, exports.calculateDuration)(normalizedWorkout, nowUnix);
+    return startTime + durationSeconds;
+};
+exports.calculateEndTime = calculateEndTime;
+const generateWorkoutTimeEvents = ({ startTimeUnix, durationSeconds, nowUnix, isPaused = false, }) => {
+    const maxPossibleDuration = nowUnix - startTimeUnix;
+    const safeRequestedDuration = (0, _1.clampNumber)(durationSeconds, {
+        min: 0,
+        max: maxPossibleDuration,
+    });
+    const pausePaddingSeconds = maxPossibleDuration - safeRequestedDuration;
+    const timeEvents = [];
+    if (pausePaddingSeconds > 0) {
+        /**
+         * The duration is shorter than (endTime - startTime). Add a pause event at
+         * the start of the workout for padding, and a resume event at the correct
+         * time to make the duration match.
+         */
+        timeEvents.push(...[
+            { type: 'pause', unixTimestamp: startTimeUnix },
+            { type: 'resume', unixTimestamp: startTimeUnix + pausePaddingSeconds },
+        ]);
+    }
+    if (isPaused) {
+        timeEvents.push({
+            type: 'pause',
+            unixTimestamp: startTimeUnix + maxPossibleDuration,
+        });
+    }
+    return timeEvents;
+};
+exports.generateWorkoutTimeEvents = generateWorkoutTimeEvents;
+const isWorkoutCurrentlyPaused = (normalizedWorkout) => {
+    var _a;
+    return ((_a = normalizedWorkout.timeEvents.slice(-1)[0]) === null || _a === void 0 ? void 0 : _a.type) === 'pause';
+};
+exports.isWorkoutCurrentlyPaused = isWorkoutCurrentlyPaused;
+/**
+ * When logging a workout, we can't just use the `completed` state of a set to
+ * determine if the user meant for the set to be included in the workout. This
+ * is because a lot of users never mark sets as completed, and forcing them to
+ * do that wouldn't add anything to the app. For that reason, we count a set as
+ * completed if it contains inputted valid values based on its exercise type.
+ * This function filters out all sets in a `NormalizedWorkout` that are
+ * incomplete based on the values inputted.
+ */
+const trimWorkout = (workout, exerciseTypeMap) => {
+    // Filter out empty sets.
+    const filteredSetsWorkout = Object.assign(Object.assign({}, workout), { exercises: workout.exercises.map((e) => {
+            return Object.assign(Object.assign({}, e), { sets: e.sets.filter((s) => {
+                    const exerciseType = exerciseTypeMap[e.exerciseTemplateId];
+                    if (!exerciseType) {
+                        /**
+                         * if we don't know the exercise type, we can't tell if the set is
+                         * empty or not, so we'll just assume that it's not.
+                         */
+                        return true;
+                    }
+                    return !isEmptySet(s, exerciseType);
+                }) });
+        }) });
+    // Filter out exercises that contain 0 sets.
+    const filteredWorkout = Object.assign(Object.assign({}, filteredSetsWorkout), { exercises: filteredSetsWorkout.exercises.filter((e) => !!e.sets.length) });
+    return filteredWorkout;
+};
+exports.trimWorkout = trimWorkout;
+const isEmptySet = (set, exerciseType) => {
+    switch (exerciseType) {
+        case 'weight_reps':
+        case 'bodyweight_reps':
+        case 'bodyweight_assisted_reps':
+        case 'reps_only':
+            return !set.reps && !set.weight;
+        case 'distance_duration':
+        case 'duration':
+            return !set.duration && !set.distance;
+        case 'short_distance_weight':
+            return !set.distance && !set.weight;
+        case 'weight_duration':
+            return !set.weight && !set.duration;
+        case 'floors_duration':
+        case 'steps_duration':
+            return !set.duration;
+    }
+};

package/built/notifications.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Notifications and Mobile pushes
+ *
+ * Notifications are types used for the in-app notification feed
+ *
+ * Mobile pushes are payloads delivered to mobile apps
+ */
+import { ClientsCoachData, Program } from '.';
+import { HevyChatUpdateMobilePushData } from './chat';
+export type Notification = WorkoutCompleteNotification | WorkoutMentionNotification | WorkoutCommentNotification | WorkoutCommentMentionNotification | WorkoutCommentReplyNotification | WorkoutCommentDiscussionNotification | WorkoutLikeNotification | WorkoutCommentLikeNotification | FollowNotification | FollowRequestNotification | AcceptFollowRequestNotification | CoachClientInviteNotification | ContactOnHevyNotification;
+export type NotificationType = 'workout-complete' | 'workout-mention' | 'workout-comment' | 'workout-comment-mention' | 'workout-comment-reply' | 'workout-comment-reply-v2' | 'workout-like' | 'workout-comment-like' | 'follow' | 'follow-request' | 'accept-follow-request' | 'coach-client-invite' | 'contact-on-hevy';
+export interface BaseNotification {
+    id: number;
+    type: NotificationType;
+    from_username: string;
+    profile_pic?: string;
+    date: string;
+}
+export interface BaseMobilePushData {
+    type: MobilePushDataType;
+    deeplink?: string;
+    profilePic?: string;
+    cue_notification_group_identifier?: string;
+    additionalHevyData?: any;
+}
+export interface WorkoutCompleteNotification extends BaseNotification {
+    type: 'workout-complete';
+    workout_id: string;
+    workout_title: string;
+}
+export interface WorkoutCompleteMobilePushData extends BaseMobilePushData {
+    type: 'workout-complete';
+}
+export interface WorkoutMentionNotification extends BaseNotification {
+    type: 'workout-mention';
+    workout_id: string;
+    workout_title: string;
+}
+export interface WorkoutMentionMobilePushData extends BaseMobilePushData {
+    type: 'workout-mention';
+}
+export interface WorkoutCommentNotification extends BaseNotification {
+    type: 'workout-comment';
+    workout_id: string;
+    workout_title: string;
+    comment: string;
+}
+export interface WorkoutCommentMobilePushData extends BaseMobilePushData {
+    type: 'workout-comment';
+}
+export interface WorkoutCommentDiscussionNotification extends BaseNotification {
+    type: 'workout-comment-reply';
+    workout_id: string;
+    workout_title: string;
+    comment: string;
+}
+export interface WorkoutCommentDiscussionMobilePushData extends BaseMobilePushData {
+    type: 'workout-comment-reply';
+}
+export interface WorkoutCommentMentionNotification extends BaseNotification {
+    type: 'workout-comment-mention';
+    workout_id: string;
+    workout_title: string;
+    comment: string;
+}
+export interface WorkoutCommentMentionMobilePushData extends BaseMobilePushData {
+    type: 'workout-comment-mention';
+}
+export interface WorkoutCommentReplyNotification extends BaseNotification {
+    type: 'workout-comment-reply-v2';
+    workout_id: string;
+    workout_title: string;
+    comment: string;
+}
+export interface WorkoutCommentReplyMobilePushData extends BaseMobilePushData {
+    type: 'workout-comment-reply-v2';
+}
+export interface WorkoutLikeNotification extends BaseNotification {
+    type: 'workout-like';
+    workout_id: string;
+    workout_title: string;
+}
+export interface WorkoutLikeMobilePushData extends BaseMobilePushData {
+    type: 'workout-like';
+}
+export interface WorkoutCommentLikeNotification extends BaseNotification {
+    type: 'workout-comment-like';
+    workout_id: string;
+    workout_title: string;
+    comment_id: number;
+    comment: string;
+}
+export interface WorkoutCommentLikeMobilePushData extends BaseMobilePushData {
+    type: 'workout-comment-like';
+}
+export interface FollowNotification extends BaseNotification {
+    type: 'follow';
+}
+export interface FollowMobilePushData extends BaseMobilePushData {
+    type: 'follow';
+}
+export interface FollowRequestNotification extends BaseNotification {
+    type: 'follow-request';
+}
+export interface FollowRequestMobilePushData extends BaseMobilePushData {
+    type: 'follow-request';
+}
+export interface AcceptFollowRequestNotification extends BaseNotification {
+    type: 'accept-follow-request';
+}
+export interface AcceptFollowRequestMobilePushData extends BaseMobilePushData {
+    type: 'accept-follow-request';
+}
+export interface CoachClientInviteNotification extends BaseNotification {
+    type: 'coach-client-invite';
+    from_full_name?: string;
+}
+export interface CoachClientInviteMobilePushData extends BaseMobilePushData {
+    type: 'coach-client-invite';
+}
+export interface ContactOnHevyNotification extends BaseNotification {
+    type: 'contact-on-hevy';
+    contact_name: string;
+}
+export interface ContactOnHevyMobilePushData extends BaseMobilePushData {
+    type: 'contact-on-hevy';
+}
+/**
+ * "Pushes": a push is basically a remote notification, NOT to be confused with a "notification", which is
+ * a data type in the Hevy database
+ */
+export type MobilePushDataType = NotificationMobilePushDataType | DataOnlyMobilePushDataType;
+/**
+ * These types will have an alert/title, and will only be delivered if the user has given the notification
+ * permission to the App
+ */
+export type NotificationMobilePushDataType = NotificationType | 'chat-update' | 'coach-program-finishes-next-week' | 'coach-program-starts-today' | 'coach-logged-your-workout' | 'coach-logged-your-measurements' | 'monthly-report' | 'grace-period-enter' | 'grace-period-resolve';
+/**
+ * These types CAN NOT have an alert/title, but may be delivered even if the user has not given the notification
+ * permission and even if Hevy isn't running, although these should be treated as best effort
+ * For iOS/Apple see https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/pushing_background_updates_to_your_app
+ * For Android see https://firebase.google.com/docs/cloud-messaging/concept-options#data_messages
+ */
+export type DataOnlyMobilePushDataType = 'coach-data-changed' | 'coach-program-changed' | 'sync-workouts' | 'sync-routines' | 'sync-routine-folders' | 'sync-exercise-templates-and-customizations' | 'sync-account' | 'hevy-pro-status-changed' | 'hevy-pro-subscription-renewed' | 'new-notification' | never;
+export interface CoachDataChangedMobilePushData extends BaseMobilePushData {
+    type: 'coach-data-changed';
+    additionalHevyData: ClientsCoachData;
+}
+export interface CoachProgramChangedMobilePushData extends BaseMobilePushData {
+    type: 'coach-program-changed';
+    additionalHevyData: {
+        program: Program | undefined;
+    };
+}
+export interface HevyProSubscriptionRenewedMobilePushData extends BaseMobilePushData {
+    type: 'hevy-pro-subscription-renewed';
+}
+export interface ProStatusChangedPushMobilePushData extends BaseMobilePushData {
+    type: 'hevy-pro-status-changed';
+}
+export interface SyncWorkoutsMobilePushData extends BaseMobilePushData {
+    type: 'sync-workouts';
+}
+export interface SyncRoutinesMobilePushData extends BaseMobilePushData {
+    type: 'sync-routines';
+}
+export interface SyncRoutineFoldersMobilePushData extends BaseMobilePushData {
+    type: 'sync-routine-folders';
+}
+export interface SyncCustomExercisesAndCoachCustomizationsMobilePushData extends BaseMobilePushData {
+    type: 'sync-exercise-templates-and-customizations';
+}
+export interface SyncAccountMobilePushData extends BaseMobilePushData {
+    type: 'sync-account';
+}
+export interface CoachProgramFinishesNextWeekMobilePushData extends BaseMobilePushData {
+    type: 'coach-program-finishes-next-week';
+}
+export interface CoachProgramStartsTodayMobilePushData extends BaseMobilePushData {
+    type: 'coach-program-starts-today';
+}
+export interface ChatUpdateMobilePushData extends BaseMobilePushData {
+    type: 'chat-update';
+    additionalHevyData: HevyChatUpdateMobilePushData;
+}
+export interface CoachLoggedYourWorkoutMobilePushData extends BaseMobilePushData {
+    type: 'coach-logged-your-workout';
+    additionalHevyData: {
+        workoutId: string;
+    };
+    deeplink: string;
+}
+export interface CoachLoggedYourMeasurementsMobilePushData extends BaseMobilePushData {
+    type: 'coach-logged-your-measurements';
+    deeplink: string;
+}
+export interface MonthlyReportMobilePushData extends BaseMobilePushData {
+    type: 'monthly-report';
+    deeplink: string;
+}
+export interface GracePeriodEnterMobilePushData extends BaseMobilePushData {
+    type: 'grace-period-enter';
+    deeplink: string;
+}
+export interface GracePeriodResolveMobilePushData extends BaseMobilePushData {
+    type: 'grace-period-resolve';
+    deeplink: string;
+}
+export interface NewNotificationMobilePushData extends BaseMobilePushData {
+    type: 'new-notification';
+    additionalHevyData: {
+        notificationDateISO: string;
+    };
+}
+export type MobilePushData = ChatUpdateMobilePushData | SyncCustomExercisesAndCoachCustomizationsMobilePushData | SyncWorkoutsMobilePushData | SyncRoutineFoldersMobilePushData | SyncRoutinesMobilePushData | SyncAccountMobilePushData | ProStatusChangedPushMobilePushData | HevyProSubscriptionRenewedMobilePushData | CoachProgramChangedMobilePushData | CoachDataChangedMobilePushData | ContactOnHevyMobilePushData | CoachClientInviteMobilePushData | AcceptFollowRequestMobilePushData | FollowRequestMobilePushData | FollowMobilePushData | WorkoutLikeMobilePushData | WorkoutCommentLikeMobilePushData | WorkoutCommentMentionMobilePushData | WorkoutCommentDiscussionMobilePushData | WorkoutCommentReplyMobilePushData | WorkoutCommentMobilePushData | WorkoutMentionMobilePushData | WorkoutCompleteMobilePushData | CoachProgramFinishesNextWeekMobilePushData | CoachProgramStartsTodayMobilePushData | CoachLoggedYourWorkoutMobilePushData | CoachLoggedYourMeasurementsMobilePushData | MonthlyReportMobilePushData | GracePeriodEnterMobilePushData | GracePeriodResolveMobilePushData | NewNotificationMobilePushData;

package/built/notifications.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Notifications and Mobile pushes
+ *
+ * Notifications are types used for the in-app notification feed
+ *
+ * Mobile pushes are payloads delivered to mobile apps
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/built/routineUtils.d.ts

@@ -0,0 +1,14 @@
+import { BaseRoutine, HevyTrainerRoutine, RoutineUpdate } from '.';
+import { NormalizedWorkout } from './normalizedWorkoutUtils';
+export declare const majorRoutineUpdate: (routine: BaseRoutine, workout: NormalizedWorkout) => RoutineUpdate;
+export declare const minorRoutineUpdate: (routine: BaseRoutine, workout: NormalizedWorkout) => RoutineUpdate;
+/**
+ * Updates a Hevy Trainer routine with the workout data.
+ * @param routine - The Hevy Trainer routine to update.
+ * @param workout - The workout data to update the routine with.
+ * @returns The updated routine.
+ *
+ * Only the rest timer seconds are updated for now.
+ */
+export declare const trainerRoutineUpdate: (routine: HevyTrainerRoutine, workout: NormalizedWorkout) => RoutineUpdate;
+export type ViewRoutineSetValueType = 'weight' | 'reps' | 'rpe' | 'repRangeStart' | 'repRangeEnd' | 'distance' | 'duration' | 'short_distance' | 'custom_metric';

package/built/routineUtils.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trainerRoutineUpdate = exports.minorRoutineUpdate = exports.majorRoutineUpdate = void 0;
+const _1 = require(".");
+const majorRoutineUpdate = (routine, workout) => {
+    var _a, _b;
+    const exercises = workout.exercises.map((e) => {
+        const occurrenceInWorkout = workout.exercises
+            .filter((it) => it.exerciseTemplateId === e.exerciseTemplateId)
+            .indexOf(e);
+        const routineExercise = routine.exercises.filter((it) => it.exercise_template_id === e.exerciseTemplateId)[occurrenceInWorkout];
+        if (!!routineExercise) {
+            const exercise = {
+                exercise_template_id: e.exerciseTemplateId,
+                superset_id: e.supersetId,
+                rest_seconds: e.autoRestTimerSeconds,
+                sets: e.sets.map((set, setIndex) => {
+                    var _a, _b;
+                    const newSet = set;
+                    const oldSet = routineExercise.sets[setIndex];
+                    return {
+                        index: setIndex,
+                        indicator: newSet.indicator,
+                        weight_kg: (newSet === null || newSet === void 0 ? void 0 : newSet.weight) || (oldSet === null || oldSet === void 0 ? void 0 : oldSet.weight_kg),
+                        reps: routineExercise.input_modifier === 'rep-range'
+                            ? undefined
+                            : (newSet === null || newSet === void 0 ? void 0 : newSet.reps) || (oldSet === null || oldSet === void 0 ? void 0 : oldSet.reps),
+                        distance_meters: (newSet === null || newSet === void 0 ? void 0 : newSet.distance) || (oldSet === null || oldSet === void 0 ? void 0 : oldSet.distance_meters),
+                        duration_seconds: (newSet === null || newSet === void 0 ? void 0 : newSet.duration) || (oldSet === null || oldSet === void 0 ? void 0 : oldSet.duration_seconds),
+                        custom_metric: (newSet === null || newSet === void 0 ? void 0 : newSet.customMetric) || (oldSet === null || oldSet === void 0 ? void 0 : oldSet.custom_metric),
+                        rpe: oldSet === null || oldSet === void 0 ? void 0 : oldSet.rpe,
+                        rep_range: routineExercise.input_modifier === 'rep-range'
+                            ? (((_a = oldSet === null || oldSet === void 0 ? void 0 : oldSet.rep_range) === null || _a === void 0 ? void 0 : _a.start) || undefined) !== undefined ||
+                                (((_b = oldSet === null || oldSet === void 0 ? void 0 : oldSet.rep_range) === null || _b === void 0 ? void 0 : _b.end) || undefined) !== undefined
+                                ? oldSet === null || oldSet === void 0 ? void 0 : oldSet.rep_range
+                                : { start: (newSet === null || newSet === void 0 ? void 0 : newSet.reps) || null, end: null }
+                            : undefined,
+                    };
+                }),
+                notes: routineExercise.notes,
+                input_modifier: routineExercise.input_modifier,
+            };
+            return exercise;
+        }
+        else {
+            const exercise = {
+                exercise_template_id: e.exerciseTemplateId,
+                superset_id: e.supersetId,
+                rest_seconds: e.autoRestTimerSeconds,
+                sets: e.sets.map((set, setIndex) => {
+                    var _a;
+                    const newSet = set;
+                    return {
+                        index: setIndex,
+                        indicator: (_a = newSet === null || newSet === void 0 ? void 0 : newSet.indicator) !== null && _a !== void 0 ? _a : set.indicator,
+                        weight_kg: newSet === null || newSet === void 0 ? void 0 : newSet.weight,
+                        reps: newSet === null || newSet === void 0 ? void 0 : newSet.reps,
+                        distance_meters: newSet === null || newSet === void 0 ? void 0 : newSet.distance,
+                        duration_seconds: newSet === null || newSet === void 0 ? void 0 : newSet.duration,
+                        custom_metric: newSet === null || newSet === void 0 ? void 0 : newSet.customMetric,
+                        rpe: undefined,
+                        rep_range: undefined,
+                    };
+                }),
+                notes: '',
+                input_modifier: undefined,
+            };
+            return exercise;
+        }
+    });
+    return {
+        title: routine.title,
+        exercises,
+        parent_routine_id: (_a = routine.parent_routine_id) !== null && _a !== void 0 ? _a : undefined,
+        folder_id: routine.folder_id,
+        index: (_b = routine.index) !== null && _b !== void 0 ? _b : 0,
+        program_id: routine.program_id,
+        notes: routine.notes,
+        coach_force_rpe_enabled: routine.coach_force_rpe_enabled,
+    };
+};
+exports.majorRoutineUpdate = majorRoutineUpdate;
+const minorRoutineUpdate = (routine, workout) => {
+    var _a, _b;
+    const exercises = routine.exercises.map((e) => {
+        const occurrenceInRoutine = routine.exercises
+            .filter((it) => it.exercise_template_id === e.exercise_template_id)
+            .indexOf(e);
+        const workoutExercise = workout.exercises.filter((it) => it.exerciseTemplateId === e.exercise_template_id)[occurrenceInRoutine];
+        if (!!workoutExercise) {
+            const exercise = {
+                exercise_template_id: workoutExercise.exerciseTemplateId,
+                superset_id: workoutExercise.supersetId,
+                rest_seconds: workoutExercise.autoRestTimerSeconds,
+                sets: e.sets.map((set, setIndex) => {
+                    var _a, _b;
+                    const setOccurrenceInRoutineExercise = e.sets
+                        .filter((it) => it.indicator === set.indicator ||
+                        (it.indicator === 'normal' && set.indicator === 'failure') ||
+                        (it.indicator === 'failure' && set.indicator === 'normal'))
+                        .indexOf(set);
+                    const workoutSet = workoutExercise.sets.filter((it) => it.indicator === set.indicator ||
+                        (it.indicator === 'normal' && set.indicator === 'failure') ||
+                        (it.indicator === 'failure' && set.indicator === 'normal'))[setOccurrenceInRoutineExercise];
+                    return {
+                        index: setIndex,
+                        indicator: set.indicator,
+                        weight_kg: (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.weight) || set.weight_kg,
+                        reps: e.input_modifier === 'rep-range'
+                            ? undefined
+                            : (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.reps) || set.reps,
+                        distance_meters: (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.distance) || set.distance_meters,
+                        duration_seconds: (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.duration) || set.duration_seconds,
+                        custom_metric: (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.customMetric) || set.custom_metric,
+                        rpe: set.rpe,
+                        rep_range: e.input_modifier === 'rep-range'
+                            ? (((_a = set.rep_range) === null || _a === void 0 ? void 0 : _a.start) || undefined) !== undefined ||
+                                (((_b = set.rep_range) === null || _b === void 0 ? void 0 : _b.end) || undefined) !== undefined
+                                ? set.rep_range
+                                : { start: (workoutSet === null || workoutSet === void 0 ? void 0 : workoutSet.reps) || set.reps || null, end: null }
+                            : undefined,
+                    };
+                }),
+                notes: e.notes,
+                input_modifier: e.input_modifier,
+            };
+            return exercise;
+        }
+        else {
+            const exercise = {
+                exercise_template_id: e.exercise_template_id,
+                superset_id: e.superset_id,
+                rest_seconds: e.rest_seconds,
+                sets: e.sets.map((set, setIndex) => ({
+                    index: setIndex,
+                    indicator: set.indicator,
+                    weight_kg: set.weight_kg,
+                    reps: set.reps,
+                    distance_meters: set.distance_meters,
+                    duration_seconds: set.duration_seconds,
+                    custom_metric: set.custom_metric,
+                    rpe: set.rpe,
+                    rep_range: set.rep_range,
+                })),
+                notes: e.notes,
+                input_modifier: e.input_modifier,
+            };
+            return exercise;
+        }
+    });
+    return {
+        title: routine.title,
+        exercises,
+        parent_routine_id: (_a = routine.parent_routine_id) !== null && _a !== void 0 ? _a : undefined,
+        folder_id: routine.folder_id,
+        index: (_b = routine.index) !== null && _b !== void 0 ? _b : 0,
+        program_id: routine.program_id,
+        notes: routine.notes,
+        coach_force_rpe_enabled: routine.coach_force_rpe_enabled,
+    };
+};
+exports.minorRoutineUpdate = minorRoutineUpdate;
+/**
+ * Updates a Hevy Trainer routine with the workout data.
+ * @param routine - The Hevy Trainer routine to update.
+ * @param workout - The workout data to update the routine with.
+ * @returns The updated routine.
+ *
+ * Only the rest timer seconds are updated for now.
+ */
+const trainerRoutineUpdate = (routine, workout) => {
+    var _a, _b;
+    return Object.assign(Object.assign({}, routine), { parent_routine_id: (_a = routine.parent_routine_id) !== null && _a !== void 0 ? _a : undefined, index: (_b = routine.index) !== null && _b !== void 0 ? _b : 0, exercises: routine.exercises.map((e) => {
+            const occurrenceInRoutine = routine.exercises
+                .filter((it) => it.exercise_template_id === e.exercise_template_id)
+                .indexOf(e);
+            const workoutExercise = (0, _1.typeSafeIndex)(workout.exercises.filter((it) => it.exerciseTemplateId === e.exercise_template_id), occurrenceInRoutine);
+            const shouldUpdateExercise = !!workoutExercise;
+            if (shouldUpdateExercise) {
+                const exercise = Object.assign(Object.assign({}, e), { rest_seconds: workoutExercise.autoRestTimerSeconds });
+                return exercise;
+            }
+            return e;
+        }) });
+};
+exports.trainerRoutineUpdate = trainerRoutineUpdate;

package/built/setIndicatorUtils.d.ts

@@ -1,5 +1,5 @@
 interface SetIndicatored {
-    indicator: 'warmup' | 'dropset' | 'failure' | 'normal' | any;
+    indicator: 'warmup' | 'dropset' | 'failure' | 'normal' | number;
 }
 interface Indexed {
     index: number;
@@ -30,7 +30,7 @@ interface Indexed {
  * ]
  * ```
  */
-export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) => (SetIndicatored & Indexed & T)[];
+export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) => Array<SetIndicatored & Indexed & T>;
 /**
  * This function is almost the exact same as `indexSetObjectsForUI`
  * but this function will change failure sets to normal. Because when
@@ -63,7 +63,8 @@ export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) =>
  * ]
  * ```
  */
-export declare const indexSetObjectsForType: <T>(indexedSet: SetIndicatored[]) => (SetIndicatored & Indexed & T)[];
+export declare const indexSetObjectsForType: <T>(indexedSet: SetIndicatored[]) => Array<SetIndicatored & Indexed & T>;
 export type UserFacingSetIndicator = 'dropset' | 'warmup' | 'failure' | number;
 export declare const setObjectToUIFacingSetIndicator: (set: SetIndicatored & Indexed) => UserFacingSetIndicator;
+export declare const compareUserFacingSetIndicator: (indicatorA: UserFacingSetIndicator, indicatorB: UserFacingSetIndicator) => boolean;
 export {};