hevy-shared 1.0.960 → 1.0.962

package/src/setIndicatorUtils.ts

@@ -0,0 +1,137 @@
+interface SetIndicatored {
+  indicator: 'warmup' | 'dropset' | 'failure' | 'normal' | any;
+}
+
+interface Indexed {
+  index: number;
+}
+
+/**
+ * Accepts any data structure like this:
+ * [
+ *  {indicator: 'warmup', index: 0, ...},
+ *  {indicator: 'normal', index: 1, ...},
+ *  {indicator: 'warmup', index: 2, ...},
+ *  {indicator: 'normal', index: 3, ...},
+ *  {indicator: 'normal', index: 4, ...},
+ *  {indicator: 'failure', index: 5, ...},
+ *  {indicator: 'dropset', index: 6, ...},
+ * ]
+ *
+ *
+ * And outputs:
+ * ```
+ * [
+ *  {indicator: 'warmup', index: 0, ...},
+ *  {indicator: 'normal', index: 0, ...},
+ *  {indicator: 'warmup', index: 1, ...},
+ *  {indicator: 'normal', index: 2, ...},
+ *  {indicator: 'normal', index: 3, ...},
+ *  {indicator: 'failure', index: 4, ...},
+ *  {indicator: 'dropset', index: 0, ...},
+ * ]
+ * ```
+ */
+
+export const indexSetObjectsForUI = <T>(
+  indexedSet: SetIndicatored[],
+): Array<SetIndicatored & Indexed & T> => {
+  return indexedSet.reduce(
+    (accu: any, currentSet: SetIndicatored) => {
+      if (currentSet.indicator === 'warmup') {
+        const newSet = { ...currentSet, index: accu.warmupCount };
+        accu.warmupCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      } else if (currentSet.indicator === 'dropset') {
+        const newSet = { ...currentSet, index: accu.dropsetCount };
+        accu.dropsetCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      } else {
+        const newSet = { ...currentSet, index: accu.normalCount };
+        accu.normalCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      }
+
+      return accu;
+    },
+    { warmupCount: 0, dropsetCount: 0, normalCount: 0, sets: [] },
+  ).sets;
+};
+
+/**
+ * This function is almost the exact same as `indexSetObjectsForUI`
+ * but this function will change failure sets to normal. Because when
+ * processing failure sets, they are often considered normal sets.
+ * For example when calculating a previous values, failure sets are
+ * considered normal sets.
+ *
+ * Accepts any data structure like this:
+ * [
+ *  {indicator: 'warmup', index: 0, ...},
+ *  {indicator: 'normal', index: 1, ...},
+ *  {indicator: 'warmup', index: 2, ...},
+ *  {indicator: 'normal', index: 3, ...},
+ *  {indicator: 'normal', index: 4, ...},
+ *  {indicator: 'failure', index: 5, ...},
+ *  {indicator: 'dropset', index: 6, ...},
+ * ]
+ *
+ *
+ * And outputs:
+ * ```
+ * [
+ *  {indicator: 'warmup', index: 0, ...},
+ *  {indicator: 'normal', index: 0, ...},
+ *  {indicator: 'warmup', index: 1, ...},
+ *  {indicator: 'normal', index: 2, ...},
+ *  {indicator: 'normal', index: 3, ...},
+ *  {indicator: 'normal', index: 4, ...}, // Note the failure set was flipped to normal.
+ *  {indicator: 'dropset', index: 0, ...},
+ * ]
+ * ```
+ */
+
+export const indexSetObjectsForType = <T>(
+  indexedSet: SetIndicatored[],
+): Array<SetIndicatored & Indexed & T> => {
+  return indexedSet.reduce(
+    (accu: any, currentSet: SetIndicatored) => {
+      if (currentSet.indicator === 'warmup') {
+        const newSet = { ...currentSet, index: accu.warmupCount };
+        accu.warmupCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      } else if (currentSet.indicator === 'dropset') {
+        const newSet = { ...currentSet, index: accu.dropsetCount };
+        accu.dropsetCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      } else {
+        const newSet = {
+          ...currentSet,
+          indicator: 'normal',
+          index: accu.normalCount,
+        };
+        accu.normalCount += 1;
+        accu.sets = [...accu.sets, newSet];
+      }
+
+      return accu;
+    },
+    { warmupCount: 0, dropsetCount: 0, normalCount: 0, sets: [] },
+  ).sets;
+};
+
+export type UserFacingSetIndicator = 'dropset' | 'warmup' | 'failure' | number;
+
+export const setObjectToUIFacingSetIndicator = (
+  set: SetIndicatored & Indexed,
+): UserFacingSetIndicator => {
+  if (
+    set.indicator === 'warmup' ||
+    set.indicator === 'dropset' ||
+    set.indicator === 'failure'
+  ) {
+    return set.indicator;
+  }
+
+  return set.index + 1;
+};

package/src/tests/utils.test.ts

@@ -0,0 +1,156 @@
+import {
+  forceStringToNumber,
+  isValidEmail,
+  isValidUsername,
+  stringToNumber,
+  removeAccents,
+  numberWithCommas,
+  isValidWebUrl,
+  isValidFormattedTime,
+  isValidPhoneNumber,
+} from '../utils';
+
+describe('utils', () => {
+  describe('isValidUsername', () => {
+    it('returns true for valid usernames', () => {
+      expect(isValidUsername('desmond')).toBe(true);
+      expect(isValidUsername('desmond_mc')).toBe(true);
+      expect(isValidUsername('desmond_mc123')).toBe(true);
+    });
+
+    it('returns false for invalid usernames', () => {
+      expect(isValidUsername('ab')).toBe(false);
+      expect(isValidUsername('desmond_')).toBe(false);
+      expect(isValidUsername('desmond.mc')).toBe(false);
+      expect(isValidUsername('desmond-mc')).toBe(false);
+      expect(isValidUsername('.desmondmc')).toBe(false);
+      expect(isValidUsername('thisusernameistolongg')).toBe(false);
+    });
+  });
+
+  describe('isValidEmail', () => {
+    it('returns true for valid email', () => {
+      expect(isValidEmail('asd@asd.com')).toBe(true);
+      expect(isValidEmail('desmond@gmail.com')).toBe(true);
+      expect(isValidEmail('something@somethingelse.asd')).toBe(true);
+    });
+
+    it('returns false for invalid emails', () => {
+      expect(isValidEmail('asdasd')).toBe(false);
+      expect(isValidEmail('asd@asd')).toBe(false);
+    });
+  });
+
+  describe('isValidUrl', () => {
+    it('returns true for valid url', () => {
+      expect(isValidWebUrl('http://hevyapp.com')).toBe(true);
+      expect(isValidWebUrl('hevyapp.com')).toBe(true);
+      expect(isValidWebUrl('https://hevyapp.com')).toBe(true);
+      expect(isValidWebUrl('hevyapp.com/')).toBe(true);
+      expect(isValidWebUrl('hevyapp.com/about-us')).toBe(true);
+      expect(isValidWebUrl('www.hevyapp.com')).toBe(true);
+      expect(isValidWebUrl('something.xd')).toBe(true);
+      expect(isValidWebUrl('my-cool.website')).toBe(true);
+    });
+    it('returns false for invalid url', () => {
+      expect(isValidWebUrl('asdasd')).toBe(false);
+      expect(isValidWebUrl('ftp://hevyapp.com')).toBe(false);
+      expect(isValidWebUrl('mailto://me@me.com')).toBe(false);
+      expect(isValidWebUrl('http://')).toBe(false);
+      expect(isValidWebUrl('https://')).toBe(false);
+      expect(isValidWebUrl('hevyapp.c')).toBe(false);
+      expect(isValidWebUrl('hevyapp.')).toBe(false);
+      expect(isValidWebUrl('hevyapp')).toBe(false);
+      expect(isValidWebUrl('This is my link')).toBe(false);
+      expect(isValidWebUrl('my_impossible.website')).toBe(false);
+    });
+  });
+
+  describe('isValidPhoneNumber', () => {
+    it('returns true for a valid phone number', () => {
+      expect(isValidPhoneNumber('+123456789')).toBe(true);
+      expect(isValidPhoneNumber('+123456789012345')).toBe(true);
+    });
+
+    it('returns false for an invalid phone number', () => {
+      expect(isValidPhoneNumber('+12345678')).toBe(false);
+      expect(isValidPhoneNumber('+123456789.')).toBe(false);
+      expect(isValidPhoneNumber('+1 23456789')).toBe(false);
+      expect(isValidPhoneNumber('123456789')).toBe(false);
+      expect(isValidPhoneNumber('+1234567890123456')).toBe(false);
+      expect(isValidPhoneNumber('not a number')).toBe(false);
+      expect(isValidPhoneNumber('+')).toBe(false);
+      expect(isValidPhoneNumber('')).toBe(false);
+    });
+  });
+
+  describe('forceStringToNumber', () => {
+    it('Takes any string and outputs a number. No matter what.', () => {
+      expect(forceStringToNumber('10')).toBe(10);
+      expect(forceStringToNumber('10.1')).toBe(10.1);
+      expect(forceStringToNumber('10,1')).toBe(10.1);
+      expect(forceStringToNumber('10.1.1.1.1.1')).toBe(0);
+      expect(forceStringToNumber('asdasdasdqwe')).toBe(0);
+      expect(forceStringToNumber('-10')).toBe(-10);
+      expect(forceStringToNumber('-10.1')).toBe(-10.1);
+      expect(forceStringToNumber('-10,1')).toBe(-10.1);
+      expect(forceStringToNumber('10.10000000000')).toBe(10.1);
+      expect(forceStringToNumber(undefined)).toBe(0);
+      expect(forceStringToNumber('')).toBe(0);
+    });
+  });
+
+  describe('stringToNumber', () => {
+    it('Takes any string and outputs a number. No matter what.', () => {
+      expect(stringToNumber('10')).toBe(10);
+      expect(stringToNumber('10.1')).toBe(10.1);
+      expect(stringToNumber('10,1')).toBe(10.1);
+      expect(stringToNumber('10.1.1.1.1.1')).toBe(undefined);
+      expect(stringToNumber('asdasdasdqwe')).toBe(undefined);
+      expect(stringToNumber('-10')).toBe(-10);
+      expect(stringToNumber('-10.1')).toBe(-10.1);
+      expect(stringToNumber('-10,1')).toBe(-10.1);
+      expect(stringToNumber('10.10000000000')).toBe(10.1);
+      expect(stringToNumber(undefined)).toBe(undefined);
+      expect(stringToNumber('')).toBe(undefined);
+    });
+  });
+
+  describe('removeAccents', () => {
+    it('Takes an input string and returns a new string with accents removed', () => {
+      expect(removeAccents('dog')).toBe('dog');
+      expect(removeAccents('Crème Brulée')).toBe('Creme Brulee');
+      expect(removeAccents('Möchte')).toBe('Mochte');
+      expect(removeAccents('Développé Couché Décliné (Machine Smith)')).toBe(
+        'Developpe Couche Decline (Machine Smith)',
+      );
+      expect(removeAccents('Français')).toBe('Francais');
+    });
+  });
+
+  describe('numberWithCommas', () => {
+    it('Takes a number and returns a string with commas in the right place', () => {
+      expect(numberWithCommas(10)).toBe('10');
+      expect(numberWithCommas(100)).toBe('100');
+      expect(numberWithCommas(1000)).toBe('1,000');
+      expect(numberWithCommas(10000)).toBe('10,000');
+      expect(numberWithCommas(100000)).toBe('100,000');
+      expect(numberWithCommas(1000000)).toBe('1,000,000');
+      expect(numberWithCommas(10000000)).toBe('10,000,000');
+      expect(numberWithCommas(100000000)).toBe('100,000,000');
+    });
+  });
+
+  describe('isValidFormattedTime', () => {
+    it('Returns true if the passed value is of format: NN:NN or NN:NN:NN', () => {
+      expect(isValidFormattedTime('abc')).toBe(false);
+      expect(isValidFormattedTime('asdfg')).toBe(false);
+      expect(isValidFormattedTime('0:00')).toBe(false);
+      expect(isValidFormattedTime('0:00:01')).toBe(false);
+
+      expect(isValidFormattedTime('99:99')).toBe(true);
+      expect(isValidFormattedTime('00:01')).toBe(true);
+      expect(isValidFormattedTime('10:00:01')).toBe(true);
+    });
+  });
+});

package/src/tests/workoutVolume.test.ts

@@ -0,0 +1,93 @@
+import { workoutVolumeSetsVolumeKg, WorkoutVolumeSet } from '../workoutVolume';
+
+describe('workoutVolume', () => {
+  describe('workoutVolumeSetsVolumeKg', () => {
+    it('calculated the correct workout volume', () => {
+      const weightRepsSet: WorkoutVolumeSet = {
+        type: 'weight_reps',
+        exerciseTemplateId: 'asd',
+        weightKg: 100,
+        reps: 10,
+        distanceMeters: 0,
+      };
+
+      const pullUpSet: WorkoutVolumeSet = {
+        type: 'reps_only',
+        exerciseTemplateId: '1B2B1E7C', // Pull Up
+        weightKg: 0,
+        reps: 10,
+        distanceMeters: 0,
+      };
+
+      const assistedPullUpSet: WorkoutVolumeSet = {
+        type: 'bodyweight_assisted_reps',
+        exerciseTemplateId: '2C37EC5E', // Pull Up (Assisted)
+        weightKg: 10,
+        reps: 10,
+        distanceMeters: 0,
+      };
+
+      const weightedPullUpSet: WorkoutVolumeSet = {
+        type: 'bodyweight_reps',
+        exerciseTemplateId: '729237D1', // Pull Up (Weighted)
+        weightKg: 10,
+        reps: 10,
+        distanceMeters: 0,
+      };
+
+      const shortDistanceWeight: WorkoutVolumeSet = {
+        type: 'short_distance_weight',
+        exerciseTemplateId: 'asd',
+        weightKg: 100,
+        reps: 0,
+        distanceMeters: 10,
+      };
+
+      expect(workoutVolumeSetsVolumeKg({ bodyweightKg: 100, sets: [] })).toBe(
+        0,
+      );
+
+      expect(
+        workoutVolumeSetsVolumeKg({ bodyweightKg: 100, sets: [weightRepsSet] }),
+      ).toBe(1000);
+
+      expect(
+        workoutVolumeSetsVolumeKg({ bodyweightKg: 100, sets: [pullUpSet] }),
+      ).toBe(1000);
+
+      expect(
+        workoutVolumeSetsVolumeKg({
+          bodyweightKg: 100,
+          sets: [assistedPullUpSet],
+        }),
+      ).toBe(900);
+
+      expect(
+        workoutVolumeSetsVolumeKg({
+          bodyweightKg: 100,
+          sets: [weightedPullUpSet],
+        }),
+      ).toBe(1100);
+
+      expect(
+        workoutVolumeSetsVolumeKg({
+          bodyweightKg: 100,
+          sets: [shortDistanceWeight],
+        }),
+      ).toBe(1000);
+
+      expect(
+        workoutVolumeSetsVolumeKg({
+          bodyweightKg: 100,
+          sets: [
+            weightRepsSet,
+            pullUpSet,
+            assistedPullUpSet,
+            weightedPullUpSet,
+            shortDistanceWeight,
+          ],
+        }),
+      ).toBe(5000);
+    });
+  });
+});

package/src/units.ts

@@ -0,0 +1,41 @@
+export const POUNDS_IN_KG = 2.20462;
+export const CM_IN_INCH = 2.54;
+export const METERS_IN_YARD = 0.9144;
+export const KILOMETERS_IN_MILE = 1.60934;
+export const YARDS_IN_A_MILE = 1760;
+export const METERS_IN_MILE = 1609.34;
+
+export const roundToTwoDecimal = (value: number) =>
+  Math.round(value * 100) / 100;
+
+export const roundToOneDecimal = (value: number) => Math.round(value * 10) / 10;
+
+export const roundToWholeNumber = (value: number) => Math.round(value);
+
+export const exactLbsToKg = (value: number) => {
+  return value / POUNDS_IN_KG;
+};
+
+export const exactKgtoLbs = (value: number) => {
+  return value * POUNDS_IN_KG;
+};
+
+export const exactInchtoCm = (value: number) => {
+  return value * CM_IN_INCH;
+};
+
+export const exactCmtoInch = (value: number) => {
+  return value / CM_IN_INCH;
+};
+
+export const exactMetersToYards = (value: number) => {
+  return value / METERS_IN_YARD;
+};
+
+export const exactMilesToMeters = (value: number) => {
+  return value * METERS_IN_MILE;
+};
+
+export const exactMetersToMiles = (meters: number) => {
+  return meters / METERS_IN_MILE;
+};