hevy-shared 1.0.960 → 1.0.962

package/built/muscleHeatmaps.d.ts

@@ -1,31 +0,0 @@
-import { MuscleGroup } from '.';
-import { Lookup } from './typeUtils';
-declare const _muscleHeatmapKeys: readonly ["abdominals", "shoulders", "chest", "lower_back", "biceps", "triceps", "upper_back", "quadriceps", "calves", "lats", "hamstrings", "glutes", "abductors", "adductors", "traps", "forearms", "neck"];
-export type MuscleHeatmapKey = Lookup<typeof _muscleHeatmapKeys>;
-export declare const isMuscleHeatmapKey: (x: string) => x is MuscleHeatmapKey;
-export type MuscleHeatmapData = {
-    [key in MuscleHeatmapKey]?: number;
-};
-/**
- * Calculates muscle group opacity from exercise data: primary muscle groups are 1.0, secondary are 0.5
- */
-export declare const getMuscleHeatmapDataForExercises: (exercises: ({
-    muscle_group: MuscleGroup;
-    other_muscles: MuscleGroup[];
-} | undefined)[]) => MuscleHeatmapData;
-/**
- *
- * @param workoutsOrRoutines An array of objects with an array of exercises
- * @param getExerciseTemplateWithId A function that returns an ExerciseTemplate (or undefined) given an ID
- * @returns MuscleHeatmapData with a value that represents how much a muscle group was used in the workouts or routines:
- * A primary muscle counts as 1.0 per workout/routine, and a secondary muscle counts as 0.5 per workout/routine
- */
-export declare const getMuscleHeatmapDataForWorkoutsOrRoutines: ({ workoutsOrRoutines, }: {
-    workoutsOrRoutines: {
-        exercises: {
-            muscle_group: MuscleGroup;
-            other_muscles: MuscleGroup[];
-        }[];
-    }[];
-}) => MuscleHeatmapData;
-export {};

package/built/muscleHeatmaps.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMuscleHeatmapDataForWorkoutsOrRoutines = exports.getMuscleHeatmapDataForExercises = exports.isMuscleHeatmapKey = void 0;
-const typeUtils_1 = require("./typeUtils");
-const _muscleHeatmapKeys = [
-    'abdominals',
-    'shoulders',
-    'chest',
-    'lower_back',
-    'biceps',
-    'triceps',
-    'upper_back',
-    'quadriceps',
-    'calves',
-    'lats',
-    'hamstrings',
-    'glutes',
-    'abductors',
-    'adductors',
-    'traps',
-    'forearms',
-    'neck',
-];
-const isMuscleHeatmapKey = (x) => (0, typeUtils_1.isInArray)(x, _muscleHeatmapKeys);
-exports.isMuscleHeatmapKey = isMuscleHeatmapKey;
-/**
- * Calculates muscle group opacity from exercise data: primary muscle groups are 1.0, secondary are 0.5
- */
-const getMuscleHeatmapDataForExercises = (exercises) => {
-    var _a;
-    // initialise all keys to 0
-    const data = _muscleHeatmapKeys.reduce((prev, curr) => (Object.assign(Object.assign({}, prev), { [curr]: 0 })), {});
-    for (const e of exercises) {
-        if (!e)
-            continue;
-        if ((0, exports.isMuscleHeatmapKey)(e.muscle_group)) {
-            data[e.muscle_group] = 1;
-        }
-        for (const m of e.other_muscles) {
-            if ((0, exports.isMuscleHeatmapKey)(m)) {
-                data[m] = Math.max((_a = data[m]) !== null && _a !== void 0 ? _a : 0, 0.5);
-            }
-        }
-    }
-    return data;
-};
-exports.getMuscleHeatmapDataForExercises = getMuscleHeatmapDataForExercises;
-/**
- *
- * @param workoutsOrRoutines An array of objects with an array of exercises
- * @param getExerciseTemplateWithId A function that returns an ExerciseTemplate (or undefined) given an ID
- * @returns MuscleHeatmapData with a value that represents how much a muscle group was used in the workouts or routines:
- * A primary muscle counts as 1.0 per workout/routine, and a secondary muscle counts as 0.5 per workout/routine
- */
-const getMuscleHeatmapDataForWorkoutsOrRoutines = ({ workoutsOrRoutines, }) => {
-    // initialise all keys to 0
-    const data = _muscleHeatmapKeys.reduce((prev, curr) => (Object.assign(Object.assign({}, prev), { [curr]: 0 })), {});
-    workoutsOrRoutines.forEach((workoutOrRoutine) => {
-        const muscleData = (0, exports.getMuscleHeatmapDataForExercises)(workoutOrRoutine.exercises);
-        Object.keys(muscleData).forEach((muscle) => {
-            data[muscle] =
-                (data[muscle] || 0) +
-                    (muscleData[muscle] || 0);
-        });
-    });
-    return data;
-};
-exports.getMuscleHeatmapDataForWorkoutsOrRoutines = getMuscleHeatmapDataForWorkoutsOrRoutines;

package/built/muscleSplits.d.ts

@@ -1,36 +0,0 @@
-import { MuscleGroup, SetType, SimplifiedMuscleGroup } from '.';
-interface SetCountableSet {
-    indicator: SetType;
-}
-interface SetCountableExercise {
-    muscle_group: MuscleGroup;
-    other_muscles: MuscleGroup[];
-    sets: SetCountableSet[];
-}
-export interface SetCountableWorkoutOrRoutine {
-    exercises: SetCountableExercise[];
-}
-export declare const calculateSetContributionsForSimplifiedMuscleGroups: ({ muscle_group, other_muscles, }: {
-    muscle_group: MuscleGroup;
-    other_muscles: MuscleGroup[];
-}) => {
-    core: number;
-    shoulders: number;
-    arms: number;
-    legs: number;
-    back: number;
-    chest: 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

@@ -1,100 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateSetCountPerMuscleGroups = exports.calculateSetContributionsForMuscleGroups = exports.calculateSimplifiedMuscleSplit = exports.calculateSetContributionsForSimplifiedMuscleGroups = void 0;
-const intersection_1 = __importDefault(require("lodash/intersection"));
-const _1 = require(".");
-const calculateSetContributionsForSimplifiedMuscleGroups = ({ muscle_group, other_muscles, }) => {
-    const getContribution = (mg) => {
-        if (mg.includes(muscle_group)) {
-            return 1;
-        }
-        else if ((0, intersection_1.default)(mg, other_muscles).length) {
-            return 0.5;
-        }
-        else if (muscle_group === 'full_body') {
-            return 1 / 6;
-        }
-        return 0;
-    };
-    return {
-        core: getContribution(_1.coreMuscles),
-        shoulders: getContribution(_1.shoulderMuscles),
-        arms: getContribution(_1.armMuscles),
-        legs: getContribution(_1.legMuscles),
-        back: getContribution(_1.backMuscles),
-        chest: getContribution(_1.chestMuscles),
-    };
-};
-exports.calculateSetContributionsForSimplifiedMuscleGroups = calculateSetContributionsForSimplifiedMuscleGroups;
-const calculateSimplifiedMuscleSplit = ({ workoutsOrRoutines, includeWarmupSets, }) => {
-    const totals = {
-        core: 0,
-        shoulders: 0,
-        arms: 0,
-        legs: 0,
-        back: 0,
-        chest: 0,
-    };
-    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.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;
-            totals.legs += contributions.legs * setCount;
-            totals.back += contributions.back * setCount;
-            totals.chest += contributions.chest * setCount;
-        }
-    }
-    return totals;
-};
-exports.calculateSimplifiedMuscleSplit = calculateSimplifiedMuscleSplit;
-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.calculateSetCountPerMuscleGroups = calculateSetCountPerMuscleGroups;

package/built/normalizedWorkoutUtils.d.ts

@@ -1,88 +0,0 @@
-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

@@ -1,112 +0,0 @@
-"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

@@ -1,215 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-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';