hevy-shared 1.0.960 → 1.0.962

package/built/tests/workoutVolume.test.js

@@ -2,184 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const workoutVolume_1 = require("../workoutVolume");
 describe('workoutVolume', () => {
-    describe('estimatedWorkoutVolumeKg', () => {
-        it('calculates the correct workout volume', () => {
-            const emptyWorkout = {
-                exercises: [],
-                include_warmup_sets: true,
+    describe('workoutVolumeSetsVolumeKg', () => {
+        it('calculated the correct workout volume', () => {
+            const weightRepsSet = {
+                type: 'weight_reps',
+                exerciseTemplateId: 'asd',
+                weightKg: 100,
+                reps: 10,
+                distanceMeters: 0,
             };
-            const weightRepsWorkout = {
-                exercises: [
-                    {
-                        exercise_type: 'weight_reps',
-                        exercise_template_id: 'asd',
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: false,
-                        sets: [
-                            {
-                                indicator: 'normal',
-                                weight_kg: 100,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                        ],
-                    },
-                ],
-                include_warmup_sets: true,
+            const pullUpSet = {
+                type: 'reps_only',
+                exerciseTemplateId: '1B2B1E7C',
+                weightKg: 0,
+                reps: 10,
+                distanceMeters: 0,
             };
-            const pullUpWorkout = {
-                exercises: [
-                    {
-                        exercise_type: 'reps_only',
-                        exercise_template_id: '1B2B1E7C', // Pull Up
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: true,
-                        sets: [
-                            {
-                                indicator: 'normal',
-                                weight_kg: 0,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                        ],
-                    },
-                ],
-                include_warmup_sets: true,
+            const assistedPullUpSet = {
+                type: 'bodyweight_assisted_reps',
+                exerciseTemplateId: '2C37EC5E',
+                weightKg: 10,
+                reps: 10,
+                distanceMeters: 0,
             };
-            const assistedPullUpWorkout = {
-                exercises: [
-                    {
-                        exercise_type: 'bodyweight_assisted_reps',
-                        exercise_template_id: '2C37EC5E', // Pull Up (Assisted)
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: true,
-                        sets: [
-                            {
-                                indicator: 'normal',
-                                weight_kg: 10,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                        ],
-                    },
-                ],
-                include_warmup_sets: true,
+            const weightedPullUpSet = {
+                type: 'bodyweight_reps',
+                exerciseTemplateId: '729237D1',
+                weightKg: 10,
+                reps: 10,
+                distanceMeters: 0,
             };
-            const weightedPullUpWorkout = {
-                exercises: [
-                    {
-                        exercise_type: 'bodyweight_reps',
-                        exercise_template_id: '729237D1', // Pull Up (Weighted)
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: true,
-                        sets: [
-                            {
-                                indicator: 'normal',
-                                weight_kg: 10,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                        ],
-                    },
-                ],
-                include_warmup_sets: true,
+            const shortDistanceWeight = {
+                type: 'short_distance_weight',
+                exerciseTemplateId: 'asd',
+                weightKg: 100,
+                reps: 0,
+                distanceMeters: 10,
             };
-            const shortDistanceWeightWorkout = {
-                exercises: [
-                    {
-                        exercise_type: 'short_distance_weight',
-                        exercise_template_id: 'asd',
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: false,
-                        sets: [
-                            {
-                                indicator: 'normal',
-                                weight_kg: 100,
-                                reps: 0,
-                                distance_meters: 10,
-                            },
-                        ],
-                    },
-                ],
-                include_warmup_sets: true,
-            };
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
-                bodyweightKg: 100,
-                workout: emptyWorkout,
-            })).toBe(0);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
-                bodyweightKg: 100,
-                workout: weightRepsWorkout,
-            })).toBe(1000);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({ bodyweightKg: 100, sets: [] })).toBe(0);
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({ bodyweightKg: 100, sets: [weightRepsSet] })).toBe(1000);
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({ bodyweightKg: 100, sets: [pullUpSet] })).toBe(1000);
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
                 bodyweightKg: 100,
-                workout: pullUpWorkout,
-            })).toBe(1000);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
-                bodyweightKg: 100,
-                workout: assistedPullUpWorkout,
+                sets: [assistedPullUpSet],
             })).toBe(900);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
                 bodyweightKg: 100,
-                workout: weightedPullUpWorkout,
+                sets: [weightedPullUpSet],
             })).toBe(1100);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
                 bodyweightKg: 100,
-                workout: shortDistanceWeightWorkout,
+                sets: [shortDistanceWeight],
             })).toBe(1000);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
+            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
                 bodyweightKg: 100,
-                workout: {
-                    exercises: [
-                        ...weightRepsWorkout.exercises,
-                        ...pullUpWorkout.exercises,
-                        ...assistedPullUpWorkout.exercises,
-                        ...weightedPullUpWorkout.exercises,
-                        ...shortDistanceWeightWorkout.exercises,
-                    ],
-                    include_warmup_sets: true,
-                },
-            })).toBe(5000);
-        });
-        it('takes warmup sets into account only if `include_warmup_sets` === `true`', () => {
-            const workoutWithWarmupSets = {
-                exercises: [
-                    {
-                        exercise_type: 'weight_reps',
-                        exercise_template_id: 'asd',
-                        volume_doubling_enabled: false,
-                        hundred_percent_bodyweight_exercise: false,
-                        sets: [
-                            {
-                                indicator: 'warmup',
-                                weight_kg: 100,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                            {
-                                indicator: 'normal',
-                                weight_kg: 100,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                            {
-                                indicator: 'normal',
-                                weight_kg: 100,
-                                reps: 10,
-                                distance_meters: 0,
-                            },
-                        ],
-                    },
+                sets: [
+                    weightRepsSet,
+                    pullUpSet,
+                    assistedPullUpSet,
+                    weightedPullUpSet,
+                    shortDistanceWeight,
                 ],
-            };
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
-                bodyweightKg: 100,
-                workout: Object.assign(Object.assign({}, workoutWithWarmupSets), { include_warmup_sets: false }),
-            })).toBe(2000);
-            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
-                bodyweightKg: 100,
-                workout: Object.assign(Object.assign({}, workoutWithWarmupSets), { include_warmup_sets: true }),
-            })).toBe(3000);
+            })).toBe(5000);
         });
     });
 });

package/built/units.d.ts

@@ -1,23 +1,16 @@
 export declare const POUNDS_IN_KG = 2.20462;
 export declare const CM_IN_INCH = 2.54;
+export declare const METERS_IN_YARD = 0.9144;
+export declare const KILOMETERS_IN_MILE = 1.60934;
+export declare const YARDS_IN_A_MILE = 1760;
 export declare const METERS_IN_MILE = 1609.34;
+export declare const roundToTwoDecimal: (value: number) => number;
+export declare const roundToOneDecimal: (value: number) => number;
+export declare const roundToWholeNumber: (value: number) => number;
 export declare const exactLbsToKg: (value: number) => number;
 export declare const exactKgtoLbs: (value: number) => number;
 export declare const exactInchtoCm: (value: number) => number;
 export declare const exactCmtoInch: (value: number) => number;
+export declare const exactMetersToYards: (value: number) => number;
 export declare const exactMilesToMeters: (value: number) => number;
 export declare const exactMetersToMiles: (meters: number) => number;
-export interface FtIn {
-    ft: number;
-    in: number;
-}
-export declare const roundedCmToFtIn: (cm: number) => {
-    ft: number;
-    in: number;
-};
-export declare const exactFtInToCm: (ftIn: FtIn) => number;
-/**
- * Round kilo- to deci- (e.g. kilograms/kg to decigrams/dg). Used for comparing
- * weight values in kg which may have originated in lbs.
- */
-export declare const roundKtoD: (value: number) => number;

package/built/units.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.roundKtoD = exports.exactFtInToCm = exports.roundedCmToFtIn = exports.exactMetersToMiles = exports.exactMilesToMeters = exports.exactCmtoInch = exports.exactInchtoCm = exports.exactKgtoLbs = exports.exactLbsToKg = exports.METERS_IN_MILE = exports.CM_IN_INCH = exports.POUNDS_IN_KG = void 0;
+exports.exactMetersToMiles = exports.exactMilesToMeters = exports.exactMetersToYards = exports.exactCmtoInch = exports.exactInchtoCm = exports.exactKgtoLbs = exports.exactLbsToKg = exports.roundToWholeNumber = exports.roundToOneDecimal = exports.roundToTwoDecimal = exports.METERS_IN_MILE = exports.YARDS_IN_A_MILE = exports.KILOMETERS_IN_MILE = exports.METERS_IN_YARD = exports.CM_IN_INCH = exports.POUNDS_IN_KG = void 0;
 exports.POUNDS_IN_KG = 2.20462;
 exports.CM_IN_INCH = 2.54;
+exports.METERS_IN_YARD = 0.9144;
+exports.KILOMETERS_IN_MILE = 1.60934;
+exports.YARDS_IN_A_MILE = 1760;
 exports.METERS_IN_MILE = 1609.34;
+const roundToTwoDecimal = (value) => Math.round(value * 100) / 100;
+exports.roundToTwoDecimal = roundToTwoDecimal;
+const roundToOneDecimal = (value) => Math.round(value * 10) / 10;
+exports.roundToOneDecimal = roundToOneDecimal;
+const roundToWholeNumber = (value) => Math.round(value);
+exports.roundToWholeNumber = roundToWholeNumber;
 const exactLbsToKg = (value) => {
     return value / exports.POUNDS_IN_KG;
 };
@@ -20,6 +29,10 @@ const exactCmtoInch = (value) => {
     return value / exports.CM_IN_INCH;
 };
 exports.exactCmtoInch = exactCmtoInch;
+const exactMetersToYards = (value) => {
+    return value / exports.METERS_IN_YARD;
+};
+exports.exactMetersToYards = exactMetersToYards;
 const exactMilesToMeters = (value) => {
     return value * exports.METERS_IN_MILE;
 };
@@ -28,26 +41,3 @@ const exactMetersToMiles = (meters) => {
     return meters / exports.METERS_IN_MILE;
 };
 exports.exactMetersToMiles = exactMetersToMiles;
-const roundedCmToFtIn = (cm) => {
-    const totalInches = (0, exports.exactCmtoInch)(cm);
-    const feet = Math.floor(totalInches / 12);
-    const inches = Math.round(totalInches % 12);
-    if (inches === 12) {
-        return { ft: feet + 1, in: 0 };
-    }
-    else {
-        return { ft: feet, in: inches };
-    }
-};
-exports.roundedCmToFtIn = roundedCmToFtIn;
-const exactFtInToCm = (ftIn) => {
-    const totalInches = ftIn.ft * 12 + ftIn.in;
-    return Math.round((0, exports.exactInchtoCm)(totalInches));
-};
-exports.exactFtInToCm = exactFtInToCm;
-/**
- * Round kilo- to deci- (e.g. kilograms/kg to decigrams/dg). Used for comparing
- * weight values in kg which may have originated in lbs.
- */
-const roundKtoD = (value) => Math.round(value * 10000);
-exports.roundKtoD = roundKtoD;

package/built/utils.d.ts

@@ -1,25 +1,12 @@
-import { Dayjs } from 'dayjs';
-import { BaseExerciseTemplate, DistanceUnit, ExerciseInstructionsStep, ExerciseType, FormatAtText, Result, SetType, StrengthLevel, UserExerciseSet, UserFacingSetIndicator, Weekday, WeightUnit } from '.';
+import { CustomExercise, ExerciseTemplate } from '.';
 /**
  * Doesn't matter what you throw in the function it'll
  * always return a number. Non number values will return
  * 0.
  */
 export declare const num: (value?: any) => number;
-export declare const clampNumber: (value: number, limits: {
-    min?: number;
-    max?: number;
-}) => number;
 export declare const divide: (numerator: number, denominator: number) => number;
-export declare const roundToTwoDecimal: (value: number) => number;
-export declare const roundToOneDecimal: (value: number) => number;
-export declare const roundToWholeNumber: (value: number) => number;
 export declare const isValidUsername: (username: string) => boolean;
-export declare const secondsToClockParts: (totalSeconds: number) => {
-    hours: number;
-    minutes: number;
-    seconds: number;
-};
 /**
  * 01:25
  * 02:25:36
@@ -34,19 +21,9 @@ export declare const secondsToWordFormat: (seconds: number) => string;
 /**
  * 14min
  * 2h 4min
- * 2h 0min
  */
 export declare const secondsToWordFormatMinutes: (seconds: number) => string;
 export declare const isValidEmail: (email: string) => boolean;
-/**
- * Matches strings with a base format of `domain.tld`.
- * - `domain` may contain letters, digits and dashes, but it can't begin or
- *   end with a dash
- * - `domain` may be prefixed once or multiple times with another `domain.`
- * - `tld` may be followed by `/path-to-page`
- * - the entire string may be prefixed by `https://` or `http://`
- */
-export declare const URL_REGEX: RegExp;
 export declare const isValidWebUrl: (url: string) => boolean;
 /**
  * Check if a string is a valid phone number. A valid phone number is a string
@@ -64,13 +41,7 @@ export declare const isValidWebUrl: (url: string) => boolean;
  * +1234567890123456
  */
 export declare const isValidPhoneNumber: (phoneNumber: string) => boolean;
-/**
- * Matches all UUID types, case-insensitive (matches both uppercase and
- * lowercase hexadecimal digits).
- */
-export declare const isValidUuid: (uuid: string) => boolean;
-export declare const isNumber: (x: any) => x is number;
-export declare const isWholeNumber: (value: number) => boolean;
+export declare const customExerciseTemplateToExerciseTemplate: (cet: CustomExercise) => ExerciseTemplate;
 /**
  * Return true is value is of format: NN:NN or NN:NN:NN
  */
@@ -84,63 +55,7 @@ export declare const forceStringToNumber: (value?: string) => number;
  * Returns a number or undefined
  */
 export declare const stringToNumber: (value?: string) => number | undefined;
-/**
- * Returns the first non-undefined value produced by transform function being
- * applied to elements of the array in iteration order, or `undefined` if no
- * such value was produced. Equivalent to `firstNotNullOfOrNull` in Kotlin.
- */
-export declare const findMapped: <T, R>(array: T[], transform: (element: T) => R) => R | undefined;
-/**
- * converts any array into an array of JSON chunks with a maximum given length
- * @param data an array of objects or primitives to be split into chunks
- * @param maxLength maximum length of any single returned JSON string
- * @returns an array of JSON strings, each one no longer than `maxLength`
- * @throws an error if fragmentation is impossible due to input data structure
- */
-export declare const toFragmentedJSON: <T>(data: T[], maxLength: number, options?: {
-    lengthIn: "utf8bytes" | "characters";
-}) => string[];
-/**
- * Finds the closest data point that occurs before or at the target date using binary search.
- * Assumes input array is sorted by date in ascending order.
- *
- * @param data - Array of items containing dates in ascending order
- * @param dateExtractor - Function to extract Date from each item
- * @param targetDate - Target date to search for
- * @returns The closest item before or at the target date, or undefined if not found
- *
- * @example
- * const data = [
- *   { id: 1, date: dayjs('2023-01-01').toDate() },
- *   { id: 2, date: dayjs('2023-04-01').toDate() }
- * ];
- * const result = getClosestDataPointBeforeTargetDate(
- *   data,
- *   item => item.date,
- *   dayjs('2023-03-15').toDate(),
- * ); // Returns { id: 1, date: Date('2023-01-01') }
- */
 export declare const getClosestDataPointBeforeTargetDate: <T>(data: T[], dateExtractor: (item: T) => Date, targetDate: Date) => T | undefined;
-/**
- * Finds the closest data point to the target date.
- *
- * @param data - Array of items containing dates
- * @param dateExtractor - Function to extract Date from each item
- * @param targetDate - Target date to search for
- * @returns The closest item to the target date, or undefined if array is empty
- *
- * @example
- * const data = [
- *   { id: 1, date: dayjs('2023-01-01').toDate() },
- *   { id: 2, date: dayjs('2023-04-01').toDate() }
- * ];
- * const result = getClosestDataPoint(
- *   data,
- *   item => item.date,
- *   dayjs('2023-03-15').toDate(),
- * ); // Returns { id: 2, date: Date('2023-04-01') }
- */
-export declare const getClosestDataPointAroundTargetDate: <T>(data: T[], dateExtractor: (item: T) => Date, targetDate: Date) => T | undefined;
 export declare const removeAccents: (str: string) => string;
 /**
  * Calculate the total duration of a workout in seconds
@@ -180,115 +95,13 @@ export interface TotalSetCountWorkout {
         sets: Array<any>;
     }>;
 }
-/**
- * Calculate the set weight for a given user exercise set
- * to be used in the exercise stats calculations on the web and coach app
- */
-export declare const userExerciseSetWeight: (set: UserExerciseSet, exerciseStore: BaseExerciseTemplate[], hundredPercentBodyweightExercise: boolean) => number;
 export declare const workoutSetCount: (w: TotalSetCountWorkout) => number;
-export declare const UserFacingIndicatorToSetIndicator: (indicator: UserFacingSetIndicator) => SetType;
-interface GetEstimatedExercisesDuration {
-    exercises: {
-        rest_seconds: number | null;
-        exercise_type: ExerciseType;
-        sets: {
-            duration_seconds?: number | null;
-            indicator: SetType;
-        }[];
-    }[];
-}
-export declare const ESTIMATED_SET_DURATION = 45;
-export declare const ESTIMATED_REST_TIMER_DURATION = 90;
-export declare const getEstimatedExercisesDurationSeconds: ({ exercises, }: GetEstimatedExercisesDuration) => number;
 export declare const oneRepMaxPercentageMap: {
     [s: number]: number;
 };
 export declare const oneRepMax: (weight: number, reps: number) => number;
 export declare const setVolume: (weight: number, reps: number) => number;
-/** @deprecated use `numberToLocaleString` */
 export declare const numberWithCommas: (x: number) => string;
-/**
- * Formats a number into a string, accounting for the system locale.
- *
- * @example
- * numberToLocaleString(1234.567) === '1,234.567' // English (UK / US)
- * numberToLocaleString(1234.567) === '1.234,567' // German (Germany)
- * numberToLocaleString(1234.567) === '1 234,567' // French (France)
- */
-export declare const numberToLocaleString: (value: number, options?: {
-    maximumFractionDigits?: number;
-}) => string;
-export declare const getStrengthLevelFromPercentile: (percentile: number) => StrengthLevel;
-export declare const isBaseExerciseTemplate: (x: any) => x is BaseExerciseTemplate;
-type GenerateUserGroupError = 'invalid-number-of-groups' | 'invalid-uuid' | 'uuid-not-v4' | 'invalid-variant';
-/**
- * Generates a subsample or test group given a user id. Technically, it just
- * calculates a trivial checksum of the last (random) part of a v4 UUID.
- * @param userId a v4 UUID; _must_ be v4 to ensure random distribution
- * @param numGroups number of possible groups, from 2 to 2^32
- * @returns a number in the `[0, numGroups)` range, always equal for a given
- * `(userId, numGroups)` pair, or an error, inside a Result<T> object
- */
-export declare const generateUserGroup: (userId: string, numGroups: number) => Result<number, GenerateUserGroupError>;
-/**
- * Get the user group value for a given user id and number of groups.
- * @param userId a v4 UUID; _must_ be v4 to ensure random distribution
- * @param numGroups number of possible groups, from 2 to 2^32
- * @returns User group value (A, B, C, etc.), or undefined if the user id is not a v4 UUID
- * or if an error occurs.
- */
-export declare const generateUserGroupValue: (userId: string, numGroups: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10) => "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | undefined;
-/**
- * @example
- * isVersionAGreaterOrEqualToVersionB('1.2.3', '1.2')    // true
- * isVersionAGreaterOrEqualToVersionB('1.2.3', '1.2.2')  // true
- * isVersionAGreaterOrEqualToVersionB('1.2.3', '1.2.3')  // true
- *
- * isVersionAGreaterOrEqualToVersionB('1.2.3', '1.2.4')  // false
- * isVersionAGreaterOrEqualToVersionB('1.2.3', '1.3')    // false
- */
-export declare const isVersionAGreaterOrEqualToVersionB: (versionA: string, versionB: string) => boolean;
-export declare const splitAtUsernamesAndLinks: (text: string) => FormatAtText[];
-export declare const validateYoutubeUrl: (url: string) => boolean;
-export declare const getYoutubeVideoId: (url: string) => string | undefined;
-/**@param workouts must be sorted descending by start_time */
-export declare const calculateCurrentWeekStreak: (workouts: {
-    start_time: number;
-}[], firstWeekday: Weekday, untilUnix?: number) => number;
-export declare const startOfWeek: (d: Dayjs, firstDayOfWeek: Weekday) => Dayjs;
-export declare const weekdayNumberMap: {
-    [key in Weekday]: number;
-};
-export declare const distance: (value: number, distanceUnit: DistanceUnit) => number;
-export declare const exerciseWeight: (value: number, weightUnit: WeightUnit) => number;
-interface getSetValueParams {
-    exerciseType: ExerciseType;
-    set: {
-        weight_kg: number | null;
-        reps: number | null;
-        duration_seconds: number | null;
-        distance_meters: number | null;
-        custom_metric: number | null;
-    };
-    units: {
-        weight: WeightUnit;
-        distance: DistanceUnit;
-    };
-    lokalizedLabels: {
-        kg: string;
-        lbs: string;
-        km: string;
-        mi: string;
-        m: string;
-        yd: string;
-        steps: string;
-        floors: string;
-    };
-}
-export declare const formatSetValue: ({ exerciseType, set, units, lokalizedLabels, }: getSetValueParams) => string;
-export declare const rawInstructionsToIndexedSteps: (rawInstructions: string) => ExerciseInstructionsStep[];
-export declare const roundToKnownValue: (value: number, knownValues: number[]) => number | undefined;
-export declare const indexByNearestValue: <T>(value: number, map: {
-    [key: number]: T;
-}) => T | undefined;
-export {};
+export declare const comparableExerciseTemplateIds: Set<string>;
+export declare const isCompareExerciseSupported: (temlpateId: string) => boolean;
+export declare const isExerciseTemplate: (x: any) => x is ExerciseTemplate;