hevy-shared 1.0.962 → 1.0.964

package/built/tests/workoutVolume.test.js

@@ -2,68 +2,184 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const workoutVolume_1 = require("../workoutVolume");
 describe('workoutVolume', () => {
-    describe('workoutVolumeSetsVolumeKg', () => {
-        it('calculated the correct workout volume', () => {
-            const weightRepsSet = {
-                type: 'weight_reps',
-                exerciseTemplateId: 'asd',
-                weightKg: 100,
-                reps: 10,
-                distanceMeters: 0,
+    describe('estimatedWorkoutVolumeKg', () => {
+        it('calculates the correct workout volume', () => {
+            const emptyWorkout = {
+                exercises: [],
+                include_warmup_sets: true,
             };
-            const pullUpSet = {
-                type: 'reps_only',
-                exerciseTemplateId: '1B2B1E7C',
-                weightKg: 0,
-                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 assistedPullUpSet = {
-                type: 'bodyweight_assisted_reps',
-                exerciseTemplateId: '2C37EC5E',
-                weightKg: 10,
-                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 weightedPullUpSet = {
-                type: 'bodyweight_reps',
-                exerciseTemplateId: '729237D1',
-                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 shortDistanceWeight = {
-                type: 'short_distance_weight',
-                exerciseTemplateId: 'asd',
-                weightKg: 100,
-                reps: 0,
-                distanceMeters: 10,
+            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,
             };
-            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)({
+            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)({
                 bodyweightKg: 100,
-                sets: [assistedPullUpSet],
+                workout: pullUpWorkout,
+            })).toBe(1000);
+            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
+                bodyweightKg: 100,
+                workout: assistedPullUpWorkout,
             })).toBe(900);
-            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
+            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
                 bodyweightKg: 100,
-                sets: [weightedPullUpSet],
+                workout: weightedPullUpWorkout,
             })).toBe(1100);
-            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
+            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
                 bodyweightKg: 100,
-                sets: [shortDistanceWeight],
+                workout: shortDistanceWeightWorkout,
             })).toBe(1000);
-            expect((0, workoutVolume_1.workoutVolumeSetsVolumeKg)({
+            expect((0, workoutVolume_1.estimatedWorkoutVolumeKg)({
                 bodyweightKg: 100,
-                sets: [
-                    weightRepsSet,
-                    pullUpSet,
-                    assistedPullUpSet,
-                    weightedPullUpSet,
-                    shortDistanceWeight,
-                ],
+                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,
+                            },
+                        ],
+                    },
+                ],
+            };
+            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);
+        });
     });
 });

package/built/translations/index.d.ts

@@ -0,0 +1,2 @@
+export * from './translationUtils';
+export * from './types';

package/built/translations/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./translationUtils"), exports);
+__exportStar(require("./types"), exports);

package/built/translations/translationUtils.d.ts

@@ -0,0 +1,2 @@
+import { PositionalTextParams, NamedTextParams, PositionalReactParams, NamedReactParams } from './types';
+export declare function interpolate<T extends string>(str: string, params: PositionalTextParams | NamedTextParams<T> | PositionalReactParams | NamedReactParams<T>): string | (string | number)[];

package/built/translations/translationUtils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolate = interpolate;
+const hasReact = (params) => Object.values(params).some((v) => v !== null &&
+    v !== undefined &&
+    typeof v !== 'string' &&
+    typeof v !== 'number' &&
+    typeof v !== 'boolean');
+function interpolate(str, params) {
+    if (Array.isArray(params)) {
+        const positionalParams = params;
+        const hasReactParams = hasReact(positionalParams);
+        const re = () => /(%s)/g;
+        let i = 0;
+        if (hasReactParams) {
+            return str
+                .split(/(%s)/g)
+                .filter((w) => !!w)
+                .map((w) => {
+                var _a, _b;
+                const [, key] = (_a = re().exec(w)) !== null && _a !== void 0 ? _a : [];
+                if (!key) {
+                    return w;
+                }
+                else {
+                    return ((_b = positionalParams[i++]) !== null && _b !== void 0 ? _b : (console.error(`Missing param ${i} in the string "${str}"`), w));
+                }
+            });
+        }
+        else {
+            return str.replace(re(), (_) => { var _a; return String((_a = positionalParams[i++]) !== null && _a !== void 0 ? _a : _); });
+        }
+    }
+    else {
+        const namedParams = params;
+        const hasReactParams = hasReact(namedParams);
+        const re = () => /%{([^}]*)}/g;
+        if (hasReactParams) {
+            return str
+                .split(/(%{[^}]*})/g)
+                .filter((w) => !!w)
+                .map((w) => {
+                var _a, _b;
+                const [, key] = (_a = re().exec(w)) !== null && _a !== void 0 ? _a : [];
+                if (!key) {
+                    if (key === '') {
+                        console.error(`Empty param in the string "${str}"`);
+                    }
+                    return w;
+                }
+                else {
+                    return ((_b = namedParams[key]) !== null && _b !== void 0 ? _b : (console.error(`Missing param "${key}" in the string "${str}"`),
+                        w));
+                }
+            });
+        }
+        else {
+            return str.replace(re(), (_, key) => { var _a; return String((_a = namedParams[key]) !== null && _a !== void 0 ? _a : _); });
+        }
+    }
+}

package/built/translations/types.d.ts

@@ -0,0 +1,8 @@
+import { Lookup } from '../typeUtils';
+export declare const supportedLanguages: readonly ["en", "es", "de", "fr", "it", "pt", "tr", "zh_CN", "zh_TW", "ru", "ja", "ko"];
+export type Language = Lookup<typeof supportedLanguages>;
+export declare const isLanguage: (x: string) => x is Language;
+export type PositionalTextParams = (string | number)[];
+export type NamedTextParams<T extends string> = Record<T, string | number>;
+export type PositionalReactParams = (string | number | object)[];
+export type NamedReactParams<T extends string> = Record<T, string | number | object>;

package/built/translations/types.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLanguage = exports.supportedLanguages = void 0;
+const typeUtils_1 = require("../typeUtils");
+exports.supportedLanguages = [
+    'en',
+    'es',
+    'de',
+    'fr',
+    'it',
+    'pt',
+    'tr',
+    'zh_CN',
+    'zh_TW',
+    'ru',
+    'ja',
+    'ko',
+];
+const isLanguage = (x) => (0, typeUtils_1.isInArray)(x, exports.supportedLanguages);
+exports.isLanguage = isLanguage;

package/built/typeUtils.d.ts

@@ -0,0 +1,70 @@
+export type Lookup<T extends readonly unknown[]> = T[number];
+export declare const isInArray: <T, ReadonlyArrayOfT extends readonly T[]>(value: T, array: ReadonlyArrayOfT) => value is Lookup<ReadonlyArrayOfT>;
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends (...args: any[]) => any ? T[P] : DeepReadonly<T[P]>;
+};
+export declare const exhaustiveTypeCheck: (_: never) => undefined;
+export declare const exhaustiveTypeException: (type: never) => Error;
+export type Some<T> = {
+    hasValue: true;
+    value: T;
+} | {
+    hasValue: false;
+};
+/**
+ * Please use this instead of using the 'as' keyword directly, so it's easier
+ * to screen for these ticking time bombs in the code from time to time. Or
+ * better yet, just implement validation for your types straight away.
+ *
+ * If you would think twice before using this, then by pure logic you should
+ * likewise also think twice - no, make it at least thrice - before making the
+ * decision to opt into undefined behaviour by letting the compile-time TS type
+ * diverge from the runtime JS value.
+ *
+ * This is your last chance to turn back.
+ *
+ * You have been warned.
+ *
+ * @example
+ * ```ts
+ * const someData = await AsyncStorage.getItem(SOME_KEY);
+ * const parsedData = JSON.parse(someData);
+ * const data = dangerousUncheckedTypeCast<SomeDataType>(parsedData);
+ * ```
+ */
+export declare const dangerousUncheckedTypeCast: <T = void, U extends T = T>(value: unknown) => U;
+/**
+ * Wrapper for TypeScript's non-nullish assertion operator (`!`). Use this
+ * instead of the operator directly so it's easier to spot. And, again, only
+ * use this if you 100% know what you're doing. If you're not sure, then don't!
+ */
+export declare const assertNonNullish: <T>(value: T) => T & {};
+/**
+ * What it's not: "I don't know what type this value may be."
+ * What it is: "I don't **CARE** about the type of this value."
+ * What it is: "Disable the type system for this variable."
+ *
+ * Alias for `any` that makes it more clear what's going on. Avoid using this,
+ * and absolutely avoid using `any` directly even harder! Instead, you may want
+ * to use one of the following:
+ *
+ * - `unknown`   // any value, can be nullish or not - need to use type guards
+ * - `unknown[]` // same as above, but we know it's an array of these unknowns,
+ *               // so we allow array functions to be used on it
+ * - `object`    // any value where `typeof value === 'object'` - except `null`
+ * - `{}`        // any non-nullish value, object or not; ignore the lint error
+ * - `never`     // no value; not `undefined` or `null`, but _unreachable code_
+ */
+export type UNSAFE_Untyped = any;
+/**
+ * Safer alternative to `JSON.parse`. Returns `unknown` instead of `any`.
+ *
+ * @see JSON.parse
+ */
+export declare const parseJSON: (...args: Parameters<typeof JSON.parse>) => unknown;
+/**
+ * Same as `array[index]`, but adds `undefined` to the return type. Maybe some
+ * fine day we will enable `noUncheckedIndexedAccess` in all our projects. 🤞
+ */
+export declare const typeSafeIndex: <T>(array: T[], index: number) => T | undefined;
+export declare const TODO: (message?: string) => never;

package/built/typeUtils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TODO = exports.typeSafeIndex = exports.parseJSON = exports.assertNonNullish = exports.dangerousUncheckedTypeCast = exports.exhaustiveTypeException = exports.exhaustiveTypeCheck = exports.isInArray = void 0;
+const isInArray = (value, array) => array.includes(value);
+exports.isInArray = isInArray;
+const exhaustiveTypeCheck = (_) => void _;
+exports.exhaustiveTypeCheck = exhaustiveTypeCheck;
+const exhaustiveTypeException = (type) => new Error(`Assertion failed: "unreachable" code reached with unknown type: ${typeof type === 'object' ? JSON.stringify(type) : String(type)}`);
+exports.exhaustiveTypeException = exhaustiveTypeException;
+/**
+ * Please use this instead of using the 'as' keyword directly, so it's easier
+ * to screen for these ticking time bombs in the code from time to time. Or
+ * better yet, just implement validation for your types straight away.
+ *
+ * If you would think twice before using this, then by pure logic you should
+ * likewise also think twice - no, make it at least thrice - before making the
+ * decision to opt into undefined behaviour by letting the compile-time TS type
+ * diverge from the runtime JS value.
+ *
+ * This is your last chance to turn back.
+ *
+ * You have been warned.
+ *
+ * @example
+ * ```ts
+ * const someData = await AsyncStorage.getItem(SOME_KEY);
+ * const parsedData = JSON.parse(someData);
+ * const data = dangerousUncheckedTypeCast<SomeDataType>(parsedData);
+ * ```
+ */
+const dangerousUncheckedTypeCast = (value) => value;
+exports.dangerousUncheckedTypeCast = dangerousUncheckedTypeCast;
+/**
+ * Wrapper for TypeScript's non-nullish assertion operator (`!`). Use this
+ * instead of the operator directly so it's easier to spot. And, again, only
+ * use this if you 100% know what you're doing. If you're not sure, then don't!
+ */
+const assertNonNullish = (value) => value;
+exports.assertNonNullish = assertNonNullish;
+/**
+ * Safer alternative to `JSON.parse`. Returns `unknown` instead of `any`.
+ *
+ * @see JSON.parse
+ */
+exports.parseJSON = JSON.parse;
+/**
+ * Same as `array[index]`, but adds `undefined` to the return type. Maybe some
+ * fine day we will enable `noUncheckedIndexedAccess` in all our projects. 🤞
+ */
+const typeSafeIndex = (array, index) => array[index];
+exports.typeSafeIndex = typeSafeIndex;
+const TODO = (message) => {
+    throw new Error(message !== null && message !== void 0 ? message : 'Not implemented');
+};
+exports.TODO = TODO;

package/built/units.d.ts

@@ -1,16 +1,23 @@
 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,18 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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.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;
 };
@@ -29,10 +20,6 @@ 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;
 };
@@ -41,3 +28,26 @@ 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;