hevy-shared 1.0.960 → 1.0.962

package/built/async.js

@@ -1,170 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LockError = exports.handleRejection = exports.allToResolveOrReject = void 0;
-exports._synchronized_3 = _synchronized_3;
-exports.synchronized = synchronized;
-/**
- * The difference between this and `Promise.all` is that `Promise.all` rejects
- * when any promise rejects, and this resolves when all promises resolve _or_
- * reject.
- *
- * This function returns an array of results, each of which is either a success
- * result containing the resolved promise, or an error result containing the
- * value that was passed to `reject()`.
- *
- * This function itself never throws or rejects.
- */
-const allToResolveOrReject = (promises) => __awaiter(void 0, void 0, void 0, function* () {
-    // Attach a dummy rejection handler to each promise as soon as possible, to
-    // try to prevent them from rejecting in the background without a handler, as
-    // that can cause issues, depending on the runtime environment.
-    //
-    promises.forEach(exports.handleRejection); // try to comment this out & run the tests
-    const results = [];
-    for (const promise of promises) {
-        try {
-            const value = yield promise;
-            results.push({ isSuccess: true, value });
-        }
-        catch (error) {
-            results.push({ isSuccess: false, error });
-        }
-    }
-    return results;
-});
-exports.allToResolveOrReject = allToResolveOrReject;
-/**
- * Attach a dummy rejection handler to a promise and return the original
- * promise. Used to prevent unhandled rejections in the background.
- *
- * To use this, wrap any `async` or `Promise`-returning function with this
- * function and use it as you otherwise would.
- *
- * Calling this multiple times for the same promise should have no ill effect.
- *
- * @example
- * // Before
- * await fetch('https://hevy.com/blabla');
- *
- * // After
- * await handleRejection(fetch('https://hevy.com/blabla'));
- */
-const handleRejection = (p) => (p.catch(() => { }), p);
-exports.handleRejection = handleRejection;
-/**
- * Do not use this directly. Use the alias provided by the parent project.
- */
-function _synchronized_3(arg0, arg1) {
-    if (typeof arg1 === 'object' &&
-        arg1 !== null &&
-        'name' in arg1 &&
-        'access' in arg1) {
-        return synchronizedStage3DecoratorFactory(arg0, arg1, true);
-    }
-    else {
-        return function (value, context) {
-            return synchronizedStage3DecoratorFactory(value, context, arg0, arg1);
-        };
-    }
-}
-function synchronized(arg0, arg1, arg2) {
-    if (arguments.length === 1) {
-        return function (target, propertyKey, descriptor) {
-            return synchronizedLegacyDecoratorFactory(target, propertyKey, descriptor, arg0);
-        };
-    }
-    else if (arguments.length === 2) {
-        return function (target, propertyKey, descriptor) {
-            return synchronizedLegacyDecoratorFactory(target, propertyKey, descriptor, arg0, arg1);
-        };
-    }
-    else {
-        return synchronizedLegacyDecoratorFactory(arg0, arg1, arg2, true);
-    }
-}
-const $queue = Symbol();
-class LockError extends Error {
-    constructor(...args) {
-        super(...args);
-    }
-}
-exports.LockError = LockError;
-class $LockError extends LockError {
-    constructor({ message: baseMessage, propertyKey, lockId, }) {
-        const formattedLockId = lockId !== undefined ? `"${String(lockId)}"` : '(anonymous)';
-        const message = `Cannot invoke "${String(propertyKey)}" (locked by ${formattedLockId}): ${baseMessage}`;
-        super(message);
-        this.name = 'LockError';
-        this.message = message;
-        this.propertyKey = propertyKey;
-        this.lockId = lockId;
-    }
-}
-function synchronizedStage3DecoratorFactory(origFn, context, wait, id) {
-    const lockId = arguments.length === 4 ? id : Symbol();
-    const propertyKey = context.name;
-    return synchronizedDecoratorFactory({
-        id,
-        lockId,
-        origFn,
-        propertyKey,
-        wait,
-    });
-}
-function synchronizedLegacyDecoratorFactory(_target, propertyKey, descriptor, wait, id) {
-    const origFn = descriptor.value;
-    const lockId = arguments.length === 5 ? id : Symbol();
-    descriptor.value = synchronizedDecoratorFactory({
-        id,
-        lockId,
-        origFn,
-        propertyKey,
-        wait,
-    });
-}
-function synchronizedDecoratorFactory({ id, lockId, origFn, propertyKey, wait, }) {
-    return function (...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            var _c;
-            const queue = ((_b = (_c = ((_a = this[$queue]) !== null && _a !== void 0 ? _a : (this[$queue] = {})))[lockId]) !== null && _b !== void 0 ? _b : (_c[lockId] = []));
-            if (queue.length > 0 && !wait) {
-                throw new $LockError({
-                    message: 'Operation is already in progress',
-                    propertyKey,
-                    lockId: id,
-                });
-            }
-            let done;
-            const thisCall = new Promise((resolve) => {
-                done = resolve;
-            });
-            const waiting = [...queue];
-            queue.push(thisCall);
-            yield (0, exports.allToResolveOrReject)(waiting);
-            try {
-                return yield origFn.apply(this, args);
-            }
-            finally {
-                done();
-                if (queue.shift() !== thisCall) {
-                    // eslint-disable-next-line no-unsafe-finally
-                    throw new $LockError({
-                        message: 'Assertion failed: @synchronized queue is mangled',
-                        propertyKey,
-                        lockId: id,
-                    });
-                }
-            }
-        });
-    };
-}

package/built/cue.d.ts

@@ -1,12 +0,0 @@
-/**
- * A = control group
- *
- * B = test group
- */
-export type CueGroup = 'a' | 'b';
-/**
- * A = control group
- *
- * B = test group
- */
-export declare const generateCueGroup: (userId: string) => CueGroup | undefined;

package/built/cue.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCueGroup = void 0;
-/**
- * A = control group
- *
- * B = test group
- */
-const generateCueGroup = (userId) => {
-    if (typeof userId !== 'string') {
-        return undefined;
-    }
-    const firstCharacter = userId.charAt(0);
-    if (['0', '1', '2', '3', '4', '5', '6', '7'].includes(firstCharacter)) {
-        return 'a';
-    }
-    if (['8', '9', 'a', 'b', 'c', 'd', 'e', 'f'].includes(firstCharacter)) {
-        return 'b';
-    }
-    return undefined;
-};
-exports.generateCueGroup = generateCueGroup;

package/built/exerciseLocaleUtils.d.ts

@@ -1,17 +0,0 @@
-import { LibraryExercise, Lookup } from '.';
-import { Language } from './translations';
-/** Keeping exercise instruction/title localization utils here instead of translations
- * so I don't need to import exercise types from here in translations (translations was
- * created so that hevy-web can import utils from shared without importing something from
- * that isn't allowed in Edge Runtime)
- */
-export declare const supportedInstructionsLanguages: readonly ["en", "it", "de", "es", "fr", "pt"];
-export type InstructionsLanguage = Lookup<typeof supportedInstructionsLanguages>;
-export declare const isSupportedInstructionsLanguage: (lang: string) => lang is InstructionsLanguage;
-type LocalizableExerciseTemplate = Pick<LibraryExercise, 'title' | 'es_title' | 'de_title' | 'fr_title' | 'it_title' | 'ja_title' | 'ko_title' | 'pt_title' | 'ru_title' | 'tr_title' | 'zh_cn_title' | 'zh_tw_title' | 'localised_instructions' | 'is_custom'>;
-export declare const localisedExerciseTitle: (locale: Language, template: LocalizableExerciseTemplate) => string;
-export declare const localisedExerciseInstructions: (locale: Language, exerciseTemplate: LocalizableExerciseTemplate) => string;
-export declare const localeSelect: <T>(locale: Language, options: {
-    en: T;
-} & { [language in Exclude<Language, "en">]?: T | null; }) => T;
-export {};

package/built/exerciseLocaleUtils.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.localeSelect = exports.localisedExerciseInstructions = exports.localisedExerciseTitle = exports.isSupportedInstructionsLanguage = exports.supportedInstructionsLanguages = void 0;
-const _1 = require(".");
-/** Keeping exercise instruction/title localization utils here instead of translations
- * so I don't need to import exercise types from here in translations (translations was
- * created so that hevy-web can import utils from shared without importing something from
- * that isn't allowed in Edge Runtime)
- */
-exports.supportedInstructionsLanguages = [
-    'en',
-    'it',
-    'de',
-    'es',
-    'fr',
-    'pt',
-];
-const isSupportedInstructionsLanguage = (lang) => {
-    return (0, _1.isInArray)(lang, exports.supportedInstructionsLanguages);
-};
-exports.isSupportedInstructionsLanguage = isSupportedInstructionsLanguage;
-const localisedExerciseTitle = (locale, template) => {
-    var _a;
-    if (template.is_custom) {
-        return template.title;
-    }
-    return ((_a = (0, exports.localeSelect)(locale, {
-        en: template.title,
-        es: template.es_title,
-        de: template.de_title,
-        fr: template.fr_title,
-        it: template.it_title,
-        pt: template.pt_title,
-        tr: template.tr_title,
-        zh_CN: template.zh_cn_title,
-        zh_TW: template.zh_tw_title,
-        ru: template.ru_title,
-        ja: template.ja_title,
-        ko: template.ko_title,
-    })) !== null && _a !== void 0 ? _a : template.title);
-};
-exports.localisedExerciseTitle = localisedExerciseTitle;
-const localisedExerciseInstructions = (locale, exerciseTemplate) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    if (exerciseTemplate.is_custom) {
-        return '';
-    }
-    return (0, exports.localeSelect)(locale, {
-        en: (_b = (_a = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _a === void 0 ? void 0 : _a.en) !== null && _b !== void 0 ? _b : '',
-        pt: (_c = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _c === void 0 ? void 0 : _c.pt,
-        de: (_d = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _d === void 0 ? void 0 : _d.de,
-        es: (_e = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _e === void 0 ? void 0 : _e.es,
-        it: (_f = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _f === void 0 ? void 0 : _f.it,
-        fr: (_g = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _g === void 0 ? void 0 : _g.fr,
-    });
-};
-exports.localisedExerciseInstructions = localisedExerciseInstructions;
-const localeSelect = (locale, options) => {
-    var _a;
-    return (_a = options[locale]) !== null && _a !== void 0 ? _a : options.en;
-};
-exports.localeSelect = localeSelect;

package/built/hevyTrainer.d.ts

@@ -1,250 +0,0 @@
-import { WeeklyTrainingFrequency, TrainingGoal, TrainingLevel, SimplifiedMuscleGroup, MuscleGroup, LibraryExercise, ExerciseCategory, GranularEquipment, HevyTrainerProgramEquipment, RestTimerLength } from '.';
-export type HevyTrainerExerciseCategory = typeof hevyTrainerExerciseCategories[number];
-export type HevyTrainerRoutineName = typeof routineNames[number];
-export declare const workoutDurationOptions: readonly [40, 60, 80];
-export type WorkoutDurationMinutes = typeof workoutDurationOptions[number];
-export declare const trainerGymTypes: readonly ["home_gym", "garage_gym", "commercial_gym", "full_gym"];
-export type TrainerGymType = typeof trainerGymTypes[number];
-export declare const granularEquipmentDefaults: {
-    [key in TrainerGymType]: GranularEquipment[];
-};
-export declare const trainerEquipmentToGranularEquipments: (equipments: HevyTrainerProgramEquipment[]) => GranularEquipment[];
-/**
- * Converts granular equipment values back to the old HevyTrainerProgramEquipment
- * types for backwards compatibility with old mobile clients.
- */
-export declare const granularEquipmentsToTrainerEquipments: (granularEquipments: GranularEquipment[]) => HevyTrainerProgramEquipment[];
-export declare const hevyTrainerExerciseCategories: readonly ["compound", "isolation"];
-export declare const defaultDurationPerFrequency: Record<WeeklyTrainingFrequency, WorkoutDurationMinutes>;
-export declare const routineNames: readonly ["full_body_1", "full_body_2_a", "full_body_2_b", "full_body_3_a", "full_body_3_b", "full_body_3_c", "upper_1_a", "lower_1_a", "upper_1_b", "lower_1_b", "push_1", "pull_1", "legs_1", "upper_2", "lower_2", "push_2_a", "pull_2_a", "legs_2_a", "push_2_b", "pull_2_b", "legs_2_b"];
-export type exerciseId = string;
-export interface ExerciseSelectionCriteria {
-    exerciseCategory: HevyTrainerExerciseCategory | 'all';
-    equipments: GranularEquipment[];
-    routineBarbellExerciseCount: number;
-    level: TrainingLevel;
-    goal: TrainingGoal;
-    muscleGroup: MuscleGroup;
-    frequency: WeeklyTrainingFrequency;
-}
-export interface ExerciseSelectionContext {
-    programUsedExerciseIds?: Set<string>;
-    routineUsedExerciseIds?: Set<string>;
-    excludedExerciseIds?: Set<string>;
-}
-export interface ExerciseSelectionParams<T extends HevyTrainerLibraryExercise> {
-    sortedExercises: Record<MuscleGroup, T[]>;
-    handPickedExercises?: T[];
-    criteria: ExerciseSelectionCriteria;
-    context: ExerciseSelectionContext;
-}
-export interface ExerciseSelectionTraceEntry {
-    pass: 1 | 2 | 3 | 4 | 5 | 6;
-    label: string;
-    candidatePoolSize: number;
-    selectedExerciseId?: string;
-}
-export interface ExerciseSelectionTrace {
-    entries: ExerciseSelectionTraceEntry[];
-    selectedPass?: 1 | 2 | 3 | 4 | 5 | 6;
-}
-export interface ProgramGenerationParams<T extends HevyTrainerLibraryExercise> {
-    trainerAlgorithmSettings: TrainerAlgorithmSettings;
-    frequency: WeeklyTrainingFrequency;
-    goal: TrainingGoal;
-    level: TrainingLevel;
-    equipments: GranularEquipment[];
-    workoutDurationMinutes: WorkoutDurationMinutes;
-    restTimerLength: RestTimerLength;
-    exerciseStore: T[];
-    focusMuscle?: SimplifiedMuscleGroup;
-    excludedExerciseIds?: Set<string>;
-    /**
-     * When enabled, includes exercise selection trace breadcrumbs in the result
-     * for debugging. Intended for troubleshooting on backoffice; keep off in
-     * normal usage on the app.
-     */
-    debugExerciseSelectionTrace?: boolean;
-}
-export interface ProgramExerciseSelectionTraceRecord {
-    routine: HevyTrainerRoutineName;
-    prescriptionIndex: number;
-    prescription: ExercisePrescription;
-    resolvedMuscleGroup: MuscleGroup;
-    criteria: ExerciseSelectionCriteria;
-    selectedExerciseId?: string;
-    trace: ExerciseSelectionTrace;
-}
-export type TrainerProgramAttemptWithTraces = TrainerProgramAttempt & {
-    exerciseSelectionTraces: ProgramExerciseSelectionTraceRecord[];
-};
-export type FrequencyString = 'one_day' | 'two_days' | 'three_days' | 'four_days' | 'five_days' | 'six_days';
-export declare const frequencyMap: Record<WeeklyTrainingFrequency, FrequencyString>;
-export declare const programSplits: Record<WeeklyTrainingFrequency, HevyTrainerRoutineName[]>;
-export type SetsPerGoal = {
-    [key in TrainingGoal]: number;
-};
-export type SetsPerFrequency = {
-    [key in FrequencyString]: SetsPerGoal;
-};
-export interface RepRange {
-    rep_range_start: number;
-    rep_range_end: number;
-}
-export type RepRangesPerCategory = {
-    [key in HevyTrainerExerciseCategory]: RepRange;
-};
-export type RepRanges = {
-    [key in TrainingGoal]: RepRangesPerCategory;
-};
-export type RestTimersPerCategory = {
-    [key in HevyTrainerExerciseCategory]: number;
-};
-export type CategoryPerRestTimerLength = {
-    [key in RestTimerLength]: RestTimersPerCategory;
-};
-export type RestTimers = {
-    [key in TrainingGoal]: CategoryPerRestTimerLength;
-};
-export type ExercisePriorities = {
-    [key in MuscleGroup]: exerciseId[];
-};
-export type ExerciseNotes = {
-    [key in exerciseId]: string;
-};
-export interface ExercisePrescription {
-    muscle_group: MuscleGroup | 'focus_muscle';
-    category: HevyTrainerExerciseCategory;
-    warmup_set_count?: number;
-    min_workout_duration_limit?: WorkoutDurationMinutes;
-}
-export type ExerciseReplacements = {
-    [key in exerciseId]: exerciseId[];
-};
-export interface WorkoutTemplate {
-    exercises: ExercisePrescription[];
-    notes?: string;
-}
-export type Templates = {
-    [key in HevyTrainerRoutineName]: WorkoutTemplate;
-};
-export interface BackofficeTrainerPreset {
-    id?: number;
-    username: string;
-    title?: string;
-    is_default?: boolean;
-    updated_at?: string;
-    settings: TrainerAlgorithmSettings;
-}
-export interface TrainerAlgorithmSettings {
-    sets: SetsPerFrequency;
-    rep_ranges: RepRanges;
-    rest_timers: RestTimers;
-    templates: Templates;
-    exercise_priorities: ExercisePriorities;
-    exercise_notes: ExerciseNotes;
-    exercise_replacements: ExerciseReplacements;
-}
-export interface TrainerProgramExercise {
-    exerciseTemplate: HevyTrainerLibraryExercise;
-    muscleGroup: MuscleGroup | 'focus_muscle';
-    category: HevyTrainerExerciseCategory;
-    sets: number;
-    warmupSetCount?: number;
-    repRangeStart: number;
-    repRangeEnd: number;
-    restTimerSeconds: number;
-    notes?: string;
-}
-export interface TrainerProgramRoutine {
-    name: HevyTrainerRoutineName;
-    exercises: TrainerProgramExercise[];
-    notes?: string;
-}
-export interface TrainerProgram {
-    name: WeeklyTrainingFrequency;
-    routines: TrainerProgramRoutine[];
-}
-export declare const getTrainerSetCount: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, frequency: WeeklyTrainingFrequency) => number;
-export declare const getTrainerRepRange: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, exerciseCategory: HevyTrainerExerciseCategory) => RepRange;
-export declare const getTrainerRestTimerSeconds: (trainerAlgorithmSettings: TrainerAlgorithmSettings, goal: TrainingGoal, length: RestTimerLength, exerciseCategory: HevyTrainerExerciseCategory) => number;
-/**
- * Normalizes the exercise category to a HevyTrainerExerciseCategory
- * - Treat custom exercises and exercises with no category as `compound`
- * - Treat `assistance-compound` as `compound`
- * - Treat `isolation` as `isolation`
- * @param exercise - The exercise to normalize the category for
- * @returns The normalized exercise category
- */
-export declare const normalizeExerciseCategory: (exercise: {
-    is_custom: boolean;
-    category?: ExerciseCategory;
-}) => HevyTrainerExerciseCategory;
-/**
- * Checks if an exercise is compatible with the user's selected granular equipments
- *
- * - If the exercise has no granular equipments, it is compatible no matter what the user has selected
- * - Otherwise, the exercise is only allowed if the user has all the granular equipments
- */
-export declare const isEquipmentCompatible: (exercise: HevyTrainerLibraryExercise, userSelectedGranularEquipments: GranularEquipment[]) => boolean;
-/**
- * Sorts exercises by priority for each muscle group based on the provided priorities
- * and adds any remaining exercises from the store that weren't in the priorities.
- *
- * @param exercisePriorities - Object mapping muscle groups to arrays of exercise IDs in priority order
- * @param exerciseStore - Array of all available exercises
- * @returns Object mapping muscle groups to arrays of exercises sorted by priority
- */
-export declare const getPrioritySortedExercises: <T extends HevyTrainerLibraryExercise>(exercisePriorities: ExercisePriorities, exerciseStore: T[]) => Record<MuscleGroup, T[]>;
-/**
- * Selects the best exercise for a given prescription using a multi-pass strategy
- */
-type PickExerciseResult<T extends HevyTrainerLibraryExercise> = {
-    exercise?: T;
-    trace: ExerciseSelectionTrace;
-};
-export declare function pickExerciseForPrescription<T extends HevyTrainerLibraryExercise>(params: ExerciseSelectionParams<T> & {
-    withTrace: true;
-}): PickExerciseResult<T>;
-export declare function pickExerciseForPrescription<T extends HevyTrainerLibraryExercise>(params: ExerciseSelectionParams<T>): T | undefined;
-export type HevyTrainerLibraryExercise = Pick<LibraryExercise, 'id' | 'title' | 'priority' | 'muscle_group' | 'other_muscles' | 'exercise_type' | 'equipment_category' | 'category' | 'level' | 'goal' | 'granular_equipments'>;
-export interface ExercisePrescriptionError {
-    type: 'exercise_not_found';
-    prescription: ExercisePrescription;
-    muscleGroup: MuscleGroup;
-    context: {
-        goal: TrainingGoal;
-        level: TrainingLevel;
-        equipments: GranularEquipment[];
-        focusMuscle?: SimplifiedMuscleGroup;
-    };
-}
-export interface TrainerProgramExerciseResult {
-    success: true;
-    exercise: TrainerProgramExercise;
-}
-export interface TrainerProgramExerciseError {
-    success: false;
-    error: ExercisePrescriptionError;
-}
-export type TrainerProgramExerciseAttempt = TrainerProgramExerciseResult | TrainerProgramExerciseError;
-export interface TrainerProgramResult {
-    success: true;
-    program: TrainerProgram;
-}
-export interface TrainerProgramError {
-    success: false;
-    errors: ExercisePrescriptionError[];
-    partialProgram: TrainerProgram;
-}
-export type TrainerProgramAttempt = TrainerProgramResult | TrainerProgramError;
-/**
- * Generates a complete training program based on the provided parameters
- * - debugExerciseSelectionTrace: true -> includes exercise selection trace breadcrumbs in the result for debugging.
- * - debugExerciseSelectionTrace: false -> no exercise selection trace breadcrumbs in the result.
- */
-export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T> & {
-    debugExerciseSelectionTrace: true;
-}): TrainerProgramAttemptWithTraces;
-export declare function generateProgram<T extends HevyTrainerLibraryExercise>(params: ProgramGenerationParams<T>): TrainerProgramAttempt;
-export {};