hevy-shared 1.0.962 → 1.0.964

package/built/tests/utils.test.js

@@ -1,5 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
 const utils_1 = require("../utils");
 describe('utils', () => {
     describe('isValidUsername', () => {
@@ -15,6 +19,7 @@ describe('utils', () => {
             expect((0, utils_1.isValidUsername)('desmond-mc')).toBe(false);
             expect((0, utils_1.isValidUsername)('.desmondmc')).toBe(false);
             expect((0, utils_1.isValidUsername)('thisusernameistolongg')).toBe(false);
+            expect((0, utils_1.isValidUsername)('Desmond')).toBe(false);
         });
     });
     describe('isValidEmail', () => {
@@ -30,16 +35,37 @@ describe('utils', () => {
     });
     describe('isValidUrl', () => {
         it('returns true for valid url', () => {
+            expect((0, utils_1.isValidWebUrl)('0-0.com')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('0--0.com')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('a.aa')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('https://a.aa')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('https://a.aa/')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('w.a.aa')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('https://w.a.aa')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('https://w.a.aa/')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('http://hevyapp.com')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('hevyapp.com')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('https://hevyapp.com')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('hevyapp.com/')).toBe(true);
+            expect((0, utils_1.isValidWebUrl)('https://hevyapp.com/')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('hevyapp.com/about-us')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('www.hevyapp.com')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('something.xd')).toBe(true);
             expect((0, utils_1.isValidWebUrl)('my-cool.website')).toBe(true);
         });
         it('returns false for invalid url', () => {
+            expect((0, utils_1.isValidWebUrl)('-.com')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('0-.com')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('-0.com')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('a.a')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('a..aa')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('.a.aa')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('..a.aa')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('a.aa.')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('hevyapp.com:1234')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('hevyapp.com:1234/')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('https://hevyapp.com:1234')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('https://hevyapp.com:1234/')).toBe(false);
             expect((0, utils_1.isValidWebUrl)('asdasd')).toBe(false);
             expect((0, utils_1.isValidWebUrl)('ftp://hevyapp.com')).toBe(false);
             expect((0, utils_1.isValidWebUrl)('mailto://me@me.com')).toBe(false);
@@ -51,6 +77,10 @@ describe('utils', () => {
             expect((0, utils_1.isValidWebUrl)('This is my link')).toBe(false);
             expect((0, utils_1.isValidWebUrl)('my_impossible.website')).toBe(false);
         });
+        it('returns false when the entire string is not a valid url', () => {
+            expect((0, utils_1.isValidWebUrl)(' https://a.aa')).toBe(false);
+            expect((0, utils_1.isValidWebUrl)('https://a.aa ')).toBe(false);
+        });
     });
     describe('isValidPhoneNumber', () => {
         it('returns true for a valid phone number', () => {
@@ -68,6 +98,76 @@ describe('utils', () => {
             expect((0, utils_1.isValidPhoneNumber)('')).toBe(false);
         });
     });
+    describe('isNumber', () => {
+        it('returns true for a number', () => {
+            expect((0, utils_1.isNumber)(1)).toBe(true);
+            expect((0, utils_1.isNumber)(0)).toBe(true);
+            expect((0, utils_1.isNumber)(100)).toBe(true);
+            expect((0, utils_1.isNumber)(1000000000)).toBe(true);
+            expect((0, utils_1.isNumber)(-1)).toBe(true);
+            expect((0, utils_1.isNumber)(-100)).toBe(true);
+            expect((0, utils_1.isNumber)(-1000000000.0)).toBe(true);
+            expect((0, utils_1.isNumber)(9.0)).toBe(true);
+            expect((0, utils_1.isNumber)(1.1)).toBe(true);
+            expect((0, utils_1.isNumber)(0.1)).toBe(true);
+            expect((0, utils_1.isNumber)(0.0000001)).toBe(true);
+            expect((0, utils_1.isNumber)(0.111111)).toBe(true);
+            expect((0, utils_1.isNumber)(100.1)).toBe(true);
+            expect((0, utils_1.isNumber)(1000000000.1)).toBe(true);
+            expect((0, utils_1.isNumber)(-1.1)).toBe(true);
+            expect((0, utils_1.isNumber)((5 * 8) / 689)).toBe(true);
+            expect((0, utils_1.isNumber)(Infinity)).toBe(true);
+            expect((0, utils_1.isNumber)(-Infinity)).toBe(true);
+            expect((0, utils_1.isNumber)(NaN)).toBe(true);
+        });
+        it('returns false for a non-number', () => {
+            expect((0, utils_1.isNumber)('')).toBe(false);
+            expect((0, utils_1.isNumber)('1')).toBe(false);
+            expect((0, utils_1.isNumber)(null)).toBe(false);
+            expect((0, utils_1.isNumber)(undefined)).toBe(false);
+            expect((0, utils_1.isNumber)(false)).toBe(false);
+            expect((0, utils_1.isNumber)(true)).toBe(false);
+            expect((0, utils_1.isNumber)({})).toBe(false);
+            expect((0, utils_1.isNumber)([])).toBe(false);
+            expect((0, utils_1.isNumber)({ number: 8 })).toBe(false);
+            expect((0, utils_1.isNumber)('1')).toBe(false);
+            expect((0, utils_1.isNumber)('0')).toBe(false);
+            expect((0, utils_1.isNumber)('100')).toBe(false);
+            expect((0, utils_1.isNumber)('1000000000')).toBe(false);
+            expect((0, utils_1.isNumber)('-1')).toBe(false);
+            expect((0, utils_1.isNumber)('-100')).toBe(false);
+            expect((0, utils_1.isNumber)('-1000000000.0')).toBe(false);
+            expect((0, utils_1.isNumber)('9.0')).toBe(false);
+            expect((0, utils_1.isNumber)('1.1')).toBe(false);
+            expect((0, utils_1.isNumber)('0.1')).toBe(false);
+            expect((0, utils_1.isNumber)('0.0000001')).toBe(false);
+            expect((0, utils_1.isNumber)('0.111111')).toBe(false);
+            expect((0, utils_1.isNumber)('100.1')).toBe(false);
+            expect((0, utils_1.isNumber)('1000000000.1')).toBe(false);
+            expect((0, utils_1.isNumber)('-1.1')).toBe(false);
+        });
+    });
+    describe('isWholeNumber', () => {
+        it('returns true for a whole number', () => {
+            expect((0, utils_1.isWholeNumber)(1)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(0)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(100)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(1000000000)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(-1)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(-100)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(-1000000000.0)).toBe(true);
+            expect((0, utils_1.isWholeNumber)(9.0)).toBe(true);
+        });
+        it('returns false for a non-whole number', () => {
+            expect((0, utils_1.isWholeNumber)(1.1)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(0.1)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(0.0000001)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(0.111111)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(100.1)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(1000000000.1)).toBe(false);
+            expect((0, utils_1.isWholeNumber)(-1.1)).toBe(false);
+        });
+    });
     describe('forceStringToNumber', () => {
         it('Takes any string and outputs a number. No matter what.', () => {
             expect((0, utils_1.forceStringToNumber)('10')).toBe(10);
@@ -98,6 +198,143 @@ describe('utils', () => {
             expect((0, utils_1.stringToNumber)('')).toBe(undefined);
         });
     });
+    describe('findMapped', () => {
+        it('Returns the first non-undefined value produced by transform function being applied to array elements', () => {
+            expect((0, utils_1.findMapped)([1, 2, 3, 4, 5], (e) => (e >= 3 ? e * 10 : undefined))).toBe(30);
+            expect((0, utils_1.findMapped)([1, 2, 3, 4, 5], (e) => (e >= 3 ? String(e) : undefined))).toBe('3');
+            expect((0, utils_1.findMapped)(['a: element 001.', 'b: element 002.', 'c: element 003.'], (e) => { var _a; return (_a = e.match(/^c: [^0-9]*([0-9]+).*$/)) === null || _a === void 0 ? void 0 : _a[1]; })).toBe('003');
+        });
+        it('Returns `undefined` if no non-undefined value was produced by transform function being applied to array elements', () => {
+            expect((0, utils_1.findMapped)([1, 2, 3, 4, 5], () => undefined)).toBeUndefined();
+            expect((0, utils_1.findMapped)([], () => true)).toBeUndefined();
+            expect((0, utils_1.findMapped)([], () => undefined)).toBeUndefined();
+        });
+    });
+    describe('toFragmentedJSON', () => {
+        it('converts any array into an array of JSON chunks with a maximum given length', () => {
+            expect((0, utils_1.toFragmentedJSON)([
+                { value: 'AAAAAAAAAAAAAAAA' },
+                { value: 'BBBBBBBBBBBBBBBBBBBBB' },
+                { value: 'CCCCCCCCCCCCCCCC' },
+            ], 64)).toEqual([
+                JSON.stringify([
+                    { value: 'AAAAAAAAAAAAAAAA' },
+                    { value: 'BBBBBBBBBBBBBBBBBBBBB' },
+                ]),
+                JSON.stringify([{ value: 'CCCCCCCCCCCCCCCC' }]),
+            ]);
+            expect((0, utils_1.toFragmentedJSON)([
+                { value: 'AAAAAAAAAAAAAAAA' },
+                { value: 'BBBBBBBBBBBBBBBBBBBBB' },
+                { value: 'CCCCCCCCCCCCCCCC' },
+            ], 35)).toEqual([
+                JSON.stringify([{ value: 'AAAAAAAAAAAAAAAA' }]),
+                JSON.stringify([{ value: 'BBBBBBBBBBBBBBBBBBBBB' }]),
+                JSON.stringify([{ value: 'CCCCCCCCCCCCCCCC' }]),
+            ]);
+            expect(() => (0, utils_1.toFragmentedJSON)([
+                { value: 'AAAAAAAAAAAAAAAA' },
+                { value: 'BBBBBBBBBBBBBBBBBBBBB' },
+                { value: 'CCCCCCCCCCCCCCCC' },
+            ], 34)).toThrow();
+            expect((0, utils_1.toFragmentedJSON)(['A', 'B', 'C'], 15)).toEqual([
+                JSON.stringify(['A', 'B', 'C']),
+            ]);
+            expect((0, utils_1.toFragmentedJSON)(['A', 'B', 'C'], 10)).toEqual([
+                JSON.stringify(['A', 'B']),
+                JSON.stringify(['C']),
+            ]);
+            expect((0, utils_1.toFragmentedJSON)(['A', 'B', 'C'], 5)).toEqual([
+                JSON.stringify(['A']),
+                JSON.stringify(['B']),
+                JSON.stringify(['C']),
+            ]);
+            expect(() => (0, utils_1.toFragmentedJSON)(['A', 'B', 'C'], 1)).toThrow();
+            expect(() => (0, utils_1.toFragmentedJSON)(['A', 'B', 'C'], 0)).toThrow();
+            expect((0, utils_1.toFragmentedJSON)([], 1)).toEqual([]);
+            expect((0, utils_1.toFragmentedJSON)([], 0)).toEqual([]);
+        });
+        it('returns an empty array for an empty input array', () => {
+            expect((0, utils_1.toFragmentedJSON)(['blah'], 100)).toEqual([
+                JSON.stringify(['blah']),
+            ]);
+            expect((0, utils_1.toFragmentedJSON)([], 100)).toEqual([]);
+            expect((0, utils_1.toFragmentedJSON)([], 100)).not.toEqual([JSON.stringify([])]);
+        });
+    });
+    describe('getClosestDataPointBeforeTargetDate', () => {
+        it('gets the closest data point before a target date, if such a data point exists, using a function to extract the date from the data points', () => {
+            var _a, _b, _c, _d;
+            expect((0, utils_1.getClosestDataPointBeforeTargetDate)([
+                { id: 1, date: new Date('2023-01-01') },
+                { id: 2, date: new Date('2023-04-01') },
+            ], (item) => new Date(item.date), new Date('2023-03-15'))).toEqual({ id: 1, date: new Date('2023-01-01') });
+            expect((_a = (0, utils_1.getClosestDataPointBeforeTargetDate)([{ key: 'abc', date: '2022-10-11' }], (item) => new Date(item.date), new Date('2022-12-21'))) === null || _a === void 0 ? void 0 : _a.key).toEqual('abc');
+            expect((_b = (0, utils_1.getClosestDataPointBeforeTargetDate)([
+                { key: 'wrong1', date: '2022-09-05' },
+                { key: 'wrong2', date: '2022-09-06' },
+                { key: 'wrong3', date: '2022-09-07' },
+                { key: 'wrong4', date: '2022-09-08' },
+                { key: 'closest', date: '2022-09-09' },
+                { key: 'wrong5', date: '2022-09-11' },
+                { key: 'wrong6', date: '2022-09-12' },
+                { key: 'wrong7', date: '2022-09-13' },
+            ], (item) => new Date(item.date), new Date('2022-09-10'))) === null || _b === void 0 ? void 0 : _b.key).toEqual('closest');
+            expect((_c = (0, utils_1.getClosestDataPointBeforeTargetDate)([
+                { key: 'wrong1', date: '2022-09-05' },
+                { key: 'wrong2', date: '2022-09-06' },
+                { key: 'wrong3', date: '2022-09-07' },
+                { key: 'wrong4', date: '2022-09-08' },
+                { key: 'wrong5', date: '2022-09-09' },
+                { key: 'exact', date: '2022-09-10' },
+                { key: 'wrong6', date: '2022-09-11' },
+                { key: 'wrong7', date: '2022-09-12' },
+                { key: 'wrong8', date: '2022-09-13' },
+            ], (item) => new Date(item.date), new Date('2022-09-10'))) === null || _c === void 0 ? void 0 : _c.key).toEqual('exact');
+            expect((_d = (0, utils_1.getClosestDataPointBeforeTargetDate)([{ key: 'abc', date: '2023-01-15' }], (item) => new Date(item.date), new Date('2022-12-21'))) === null || _d === void 0 ? void 0 : _d.key).toBeUndefined();
+        });
+    });
+    describe('getClosestDataPointAroundTargetDate', () => {
+        it('gets the closest data point to a target date, if such a data point exists, using a function to extract the date from the data points', () => {
+            var _a, _b, _c, _d;
+            expect((0, utils_1.getClosestDataPointAroundTargetDate)([
+                { id: 1, date: new Date('2023-01-01') },
+                { id: 2, date: new Date('2023-04-01') },
+            ], (item) => new Date(item.date), new Date('2023-03-15'))).toEqual({ id: 2, date: new Date('2023-04-01') });
+            // Test single point - should return it as closest
+            expect((_a = (0, utils_1.getClosestDataPointAroundTargetDate)([{ key: 'abc', date: '2022-10-11' }], (item) => new Date(item.date), new Date('2022-12-21'))) === null || _a === void 0 ? void 0 : _a.key).toEqual('abc');
+            // Test multiple points - should return closest by absolute difference
+            expect((_b = (0, utils_1.getClosestDataPointAroundTargetDate)([
+                { key: 'wrong1', date: '2022-09-05' },
+                { key: 'wrong2', date: '2022-09-06' },
+                { key: 'wrong3', date: '2022-09-07' },
+                { key: 'wrong4', date: '2022-09-08' },
+                { key: 'closest', date: '2022-09-09' }, // 1 day before
+                { key: 'alsoClose', date: '2022-09-11' }, // 1 day after
+                { key: 'wrong6', date: '2022-09-12' },
+                { key: 'wrong7', date: '2022-09-13' },
+            ], (item) => new Date(item.date), new Date('2022-09-10'))) === null || _b === void 0 ? void 0 : _b.key).toEqual('closest'); // Should pick the earlier date when equidistant
+            // Test exact match
+            expect((_c = (0, utils_1.getClosestDataPointAroundTargetDate)([
+                { key: 'wrong1', date: '2022-09-05' },
+                { key: 'wrong2', date: '2022-09-06' },
+                { key: 'wrong3', date: '2022-09-07' },
+                { key: 'wrong4', date: '2022-09-08' },
+                { key: 'wrong5', date: '2022-09-09' },
+                { key: 'exact', date: '2022-09-10' },
+                { key: 'wrong6', date: '2022-09-11' },
+                { key: 'wrong7', date: '2022-09-12' },
+            ], (item) => new Date(item.date), new Date('2022-09-10'))) === null || _c === void 0 ? void 0 : _c.key).toEqual('exact');
+            // Test empty array
+            expect((0, utils_1.getClosestDataPointAroundTargetDate)([], (item) => new Date(item.date), new Date('2022-09-10'))).toBeUndefined();
+            // Test closest when target is between two dates
+            expect((_d = (0, utils_1.getClosestDataPointAroundTargetDate)([
+                { key: 'further', date: '2022-09-08' },
+                { key: 'closest', date: '2022-09-09' },
+                { key: 'secondClosest', date: '2022-09-12' },
+            ], (item) => new Date(item.date), new Date('2022-09-10'))) === null || _d === void 0 ? void 0 : _d.key).toEqual('closest');
+        });
+    });
     describe('removeAccents', () => {
         it('Takes an input string and returns a new string with accents removed', () => {
             expect((0, utils_1.removeAccents)('dog')).toBe('dog');
@@ -125,9 +362,520 @@ describe('utils', () => {
             expect((0, utils_1.isValidFormattedTime)('asdfg')).toBe(false);
             expect((0, utils_1.isValidFormattedTime)('0:00')).toBe(false);
             expect((0, utils_1.isValidFormattedTime)('0:00:01')).toBe(false);
+            expect((0, utils_1.isValidFormattedTime)('2:10')).toBe(false);
             expect((0, utils_1.isValidFormattedTime)('99:99')).toBe(true);
             expect((0, utils_1.isValidFormattedTime)('00:01')).toBe(true);
             expect((0, utils_1.isValidFormattedTime)('10:00:01')).toBe(true);
         });
     });
+    describe('formatDurationInput', () => {
+        it('Returns a string in the format of NN:NN or NN:NN:NN', () => {
+            expect((0, utils_1.formatDurationInput)('0')).toBe('');
+            expect((0, utils_1.formatDurationInput)('1')).toBe('00:01');
+            expect((0, utils_1.formatDurationInput)('60')).toBe(undefined);
+            expect((0, utils_1.formatDurationInput)('61')).toBe(undefined);
+            expect((0, utils_1.formatDurationInput)('99:99')).toBe('99:99');
+        });
+    });
+    describe('getEstimatedExercisesDurationSeconds', () => {
+        const testCases = [
+            {
+                exercises: [
+                    {
+                        exercise_type: 'duration',
+                        rest_seconds: 10,
+                        sets: [{ duration_seconds: 50, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: 50 + 10,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'floors_duration',
+                        rest_seconds: 10,
+                        sets: [{ duration_seconds: 0, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: 10,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'weight_duration',
+                        rest_seconds: null,
+                        sets: [{ duration_seconds: 30, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: 30 + utils_1.ESTIMATED_REST_TIMER_DURATION,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'distance_duration',
+                        rest_seconds: 120,
+                        sets: [{ duration_seconds: 40, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: 40 + 120,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'weight_duration',
+                        rest_seconds: 120,
+                        sets: [{ duration_seconds: null, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: 120 + utils_1.ESTIMATED_SET_DURATION,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'duration',
+                        rest_seconds: 0,
+                        sets: [{ duration_seconds: null, indicator: 'normal' }],
+                    },
+                ],
+                expectedDuration: utils_1.ESTIMATED_SET_DURATION,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'reps_only',
+                        rest_seconds: 180,
+                        sets: [{ duration_seconds: null, indicator: 'normal' }],
+                    },
+                    {
+                        exercise_type: 'reps_only',
+                        rest_seconds: 180,
+                        sets: [
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                        ],
+                    },
+                ],
+                expectedDuration: (180 + utils_1.ESTIMATED_SET_DURATION) * 5,
+            },
+            {
+                exercises: [
+                    {
+                        exercise_type: 'reps_only',
+                        rest_seconds: null,
+                        sets: [{ duration_seconds: null, indicator: 'normal' }],
+                    },
+                    {
+                        exercise_type: 'reps_only',
+                        rest_seconds: null,
+                        sets: [
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'dropset',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'normal',
+                            },
+                            {
+                                duration_seconds: 0,
+                                indicator: 'dropset',
+                            },
+                        ],
+                    },
+                ],
+                expectedDuration: utils_1.ESTIMATED_REST_TIMER_DURATION * 3 + 5 * utils_1.ESTIMATED_SET_DURATION,
+            },
+        ];
+        testCases.forEach((testCase) => {
+            it(`getEstimatedExercisesDurationSeconds`, () => {
+                expect((0, utils_1.getEstimatedExercisesDurationSeconds)(testCase)).toBe(testCase.expectedDuration);
+            });
+        });
+    });
+    describe('splitAtUsernamesAndLinks', () => {
+        it('Takes a string and returns an array of FormatAtText', () => {
+            const inputOutputs = [
+                [
+                    'No mentions in this',
+                    [{ format: 'none', text: 'No mentions in this' }],
+                ],
+                [
+                    'Crazy workout with @guillemros',
+                    [
+                        { format: 'none', text: 'Crazy workout with ' },
+                        { format: '@', text: '@guillemros' },
+                    ],
+                ],
+                [
+                    '@himynameisivo and @guillemros are crazy!',
+                    [
+                        { format: '@', text: '@himynameisivo' },
+                        { format: 'none', text: ' and ' },
+                        { format: '@', text: '@guillemros' },
+                        { format: 'none', text: ' are crazy!' },
+                    ],
+                ],
+                [
+                    'Worked out with @himynameisivo and @guillemros!',
+                    [
+                        { format: 'none', text: 'Worked out with ' },
+                        { format: '@', text: '@himynameisivo' },
+                        { format: 'none', text: ' and ' },
+                        { format: '@', text: '@guillemros' },
+                        { format: 'none', text: '!' },
+                    ],
+                ],
+                [
+                    '@himynameisivo @guillemros!',
+                    [
+                        { format: '@', text: '@himynameisivo' },
+                        { format: 'none', text: ' ' },
+                        { format: '@', text: '@guillemros' },
+                        { format: 'none', text: '!' },
+                    ],
+                ],
+                [
+                    '@12345 @123_123!',
+                    [
+                        { format: '@', text: '@12345' },
+                        { format: 'none', text: ' ' },
+                        { format: '@', text: '@123_123' },
+                        { format: 'none', text: '!' },
+                    ],
+                ],
+                [
+                    '@12345 www.google.com! hey',
+                    [
+                        { format: '@', text: '@12345' },
+                        { format: 'none', text: ' ' },
+                        { format: 'link', text: 'www.google.com' },
+                        { format: 'none', text: '! hey' },
+                    ],
+                ],
+                [
+                    'hey www.google.com youtube.com https://example.com',
+                    [
+                        { format: 'none', text: 'hey ' },
+                        { format: 'link', text: 'www.google.com' },
+                        { format: 'none', text: ' ' },
+                        { format: 'link', text: 'youtube.com' },
+                        { format: 'none', text: ' ' },
+                        { format: 'link', text: 'https://example.com' },
+                    ],
+                ],
+                [
+                    'hey Test - https://www.tiktok.com/@tylerpath/video/7471271437467405614 @test',
+                    [
+                        { format: 'none', text: 'hey Test - ' },
+                        {
+                            format: 'link',
+                            text: 'https://www.tiktok.com/@tylerpath/video/7471271437467405614',
+                        },
+                        { format: 'none', text: ' ' },
+                        { format: '@', text: '@test' },
+                    ],
+                ],
+            ];
+            inputOutputs.forEach((i) => {
+                expect((0, utils_1.splitAtUsernamesAndLinks)(i[0])).toEqual(i[1]);
+            });
+        });
+    });
+    describe('generateUserGroup', () => {
+        it('generates a subsample or test group given a user id', () => {
+            expect((0, utils_1.generateUserGroup)('0a83932f-c3d4-4cbb-acfc-db48c09a362d', 2)).toEqual({
+                isSuccess: true,
+                value: Number(BigInt('0xdb48c09a362d') % BigInt(2)),
+            });
+            expect((0, utils_1.generateUserGroup)('2B022B1F-93C7-4C8F-9677-9F3000B29D2A', 3)).toEqual({
+                isSuccess: true,
+                value: Number(BigInt('0x9f3000b29d2a') % BigInt(3)),
+            });
+            expect((0, utils_1.generateUserGroup)('7693699a-afe7-4DEC-D07E-9694d2de3920', 1000)).toEqual({
+                isSuccess: true,
+                value: Number(BigInt('0x9694d2de3920') % BigInt(1000)),
+            });
+        });
+        it('fails when given an invalid input', () => {
+            expect((0, utils_1.generateUserGroup)('c1abee8a-461a-414c-9a2f-f1ba120cb8c7', 1)).toEqual({
+                isSuccess: false,
+                error: 'invalid-number-of-groups',
+            });
+            expect((0, utils_1.generateUserGroup)('absolutely-no-UUID-to-be-found-here', 2)).toEqual({
+                isSuccess: false,
+                error: 'invalid-uuid',
+            });
+            expect((0, utils_1.generateUserGroup)('3187b48c-d9bd-11ef-a2ec-325096b39f47', 2)).toEqual({
+                isSuccess: false,
+                error: 'uuid-not-v4',
+            });
+            expect((0, utils_1.generateUserGroup)('baa45206-475e-4bf5-7a9d-a21fd3d6966d', 2)).toEqual({
+                isSuccess: false,
+                error: 'invalid-variant',
+            });
+        });
+    });
+    describe('validateYoutubeUrl', () => {
+        it('returns true for valid YouTube URLs', () => {
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/watch?v=dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://youtube.com/watch?v=dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('http://youtube.com/watch?v=dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('youtube.com/watch?v=dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://youtu.be/dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/shorts/dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/embed/dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/v/dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://youtube.com/shorts/dQw4w9WgXcQ')).toBe(true);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=10s')).toBe(true);
+        });
+        it('returns false for invalid YouTube URLs', () => {
+            expect((0, utils_1.validateYoutubeUrl)('https://www.notbyoutube.com/watch?v=dQw4w9WgXcQ')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.org/watch?v=dQw4w9WgXcQ')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/notWatch?v=dQw4w9WgXcQ')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/watch?id=dQw4w9WgXcQ')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtube.com/watch?v=short')).toBe(false); // Too short ID
+            expect((0, utils_1.validateYoutubeUrl)('https://www.youtu.be/dQw4w9WgXcQ')).toBe(false); // Invalid domain
+            expect((0, utils_1.validateYoutubeUrl)('https://www.vimeo.com/123456789')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('')).toBe(false);
+            expect((0, utils_1.validateYoutubeUrl)('not a url')).toBe(false);
+        });
+    });
+    describe('getYoutubeVideoId', () => {
+        it('extracts video ID from standard YouTube URLs', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://youtube.com/watch?v=dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('http://www.youtube.com/watch?v=dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('youtube.com/watch?v=dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=10s')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://youtu.be/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/embed/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/v/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+        });
+        it('extracts video ID from YouTube Shorts URLs', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/shorts/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://youtube.com/shorts/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('youtube.com/shorts/dQw4w9WgXcQ')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/shorts/dQw4w9WgXcQ?feature=share')).toBe('dQw4w9WgXcQ');
+        });
+        it('returns undefined for invalid YouTube URLs', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.notYoutube.com/watch?v=dQw4w9WgXcQ')).toBeUndefined();
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.org/watch?v=dQw4w9WgXcQ')).toBeUndefined();
+            expect((0, utils_1.getYoutubeVideoId)('https://www.vimeo.com/123456789')).toBeUndefined();
+            expect((0, utils_1.getYoutubeVideoId)('')).toBeUndefined();
+            expect((0, utils_1.getYoutubeVideoId)('not a url')).toBeUndefined();
+        });
+        it('returns undefined for invalid video IDs', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=short')).toBeUndefined(); // ID too short
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/shorts/short')).toBeUndefined(); // ID too short
+        });
+        it('extracts video ID from videos in playlists', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&list=PLlaN88a7y2_plecYoJxvRFTLHVbIVAOoS')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&list=PLlaN88a7y2_plecYoJxvRFTLHVbIVAOoS&index=2')).toBe('dQw4w9WgXcQ');
+        });
+        it('extracts video ID from videos from channels', () => {
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=channel')).toBe('dQw4w9WgXcQ');
+            expect((0, utils_1.getYoutubeVideoId)('https://www.youtube.com/watch?v=dQw4w9WgXcQ&ab_channel=RickAstleyVEVO')).toBe('dQw4w9WgXcQ');
+        });
+    });
+    describe('calculateCurrentWeekStreak', () => {
+        it("Doesn't include gaps in the streak count", () => {
+            const workouts = [
+                { start_time: (0, dayjs_1.default)('2025-11-05').unix() },
+                { start_time: (0, dayjs_1.default)('2025-11-02').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-31').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-23').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-10').unix() },
+            ];
+            const firstWeekday = 'sunday';
+            const untilUnix = (0, dayjs_1.default)('2025-11-06').unix();
+            expect((0, utils_1.calculateCurrentWeekStreak)(workouts, firstWeekday, untilUnix)).toBe(3);
+        });
+        it("Calculates a potentially non-zero streak when the user hasn't worked out this week yet", () => {
+            const workouts = [
+                { start_time: (0, dayjs_1.default)('2025-10-31').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-23').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-20').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-14').unix() + 1 },
+                { start_time: (0, dayjs_1.default)('2025-10-12').unix() },
+            ];
+            const firstWeekday = 'monday';
+            const untilUnix = (0, dayjs_1.default)('2025-11-06').unix();
+            expect((0, utils_1.calculateCurrentWeekStreak)(workouts, firstWeekday, untilUnix)).toBe(4);
+        });
+        it('Includes this week in the streak count if the user worked out this week', () => {
+            const workouts = [
+                { start_time: (0, dayjs_1.default)('2025-11-05').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-31').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-23').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-20').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-14').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-07').unix() },
+            ];
+            const firstWeekday = 'monday';
+            const untilUnix = (0, dayjs_1.default)('2025-11-06').unix();
+            expect((0, utils_1.calculateCurrentWeekStreak)(workouts, firstWeekday, untilUnix)).toBe(5);
+        });
+        it("Returns 0 if the user hasn't worked out", () => {
+            const workouts = [];
+            const firstWeekday = 'friday';
+            const untilUnix = (0, dayjs_1.default)('2025-10-10').unix();
+            expect((0, utils_1.calculateCurrentWeekStreak)(workouts, firstWeekday, untilUnix)).toBe(0);
+        });
+        it('Returns 0 if the user has not worked out this week and last week', () => {
+            const workouts = [
+                { start_time: (0, dayjs_1.default)('2025-10-23').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-20').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-13').unix() },
+                { start_time: (0, dayjs_1.default)('2025-10-07').unix() },
+            ];
+            const firstWeekday = 'sunday';
+            const untilUnix = (0, dayjs_1.default)('2025-11-05').unix();
+            expect((0, utils_1.calculateCurrentWeekStreak)(workouts, firstWeekday, untilUnix)).toBe(0);
+        });
+    });
+    describe('formatSetValue', () => {
+        const baseParams = {
+            set: {
+                weight_kg: 100,
+                reps: 10,
+                duration_seconds: 90,
+                distance_meters: 1500,
+                custom_metric: 15,
+            },
+            units: {
+                weight: 'kg',
+                distance: 'kilometers',
+            },
+            lokalizedLabels: {
+                kg: 'kg',
+                lbs: 'lbs',
+                km: 'km',
+                mi: 'mi',
+                m: 'm',
+                yd: 'yd',
+                steps: 'Steps',
+                floors: 'Floors',
+            },
+        };
+        it('formats weight and reps for weight-based exercises', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'weight_reps' }))).toBe('100 kg x 10');
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'bodyweight_reps' }))).toBe('100 kg x 10');
+        });
+        it('formats assisted bodyweight reps with negative weight', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'bodyweight_assisted_reps', set: Object.assign(Object.assign({}, baseParams.set), { weight_kg: 15, reps: 8 }) }))).toBe('-15 kg x 8');
+        });
+        it('formats reps-only exercises', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'reps_only' }))).toBe('10');
+        });
+        it('formats distance with duration', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'distance_duration' }))).toBe('1.5 km - 1min 30s');
+        });
+        it('formats duration-only exercises', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'duration' }))).toBe('1min 30s');
+        });
+        it('formats short distance with weight', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'short_distance_weight', set: Object.assign(Object.assign({}, baseParams.set), { distance_meters: 250 }) }))).toBe('100 kg - 250 m');
+        });
+        it('handles null reps as zero', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'weight_reps', set: Object.assign(Object.assign({}, baseParams.set), { reps: null }) }))).toBe('100 kg x 0');
+        });
+        it('formats weight with duration', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'weight_duration' }))).toBe('100 kg - 1min 30s');
+        });
+        it('formats weights in kg', () => {
+            expect((0, utils_1.formatSetValue)({
+                set: {
+                    weight_kg: 100,
+                    reps: 12,
+                    duration_seconds: null,
+                    distance_meters: null,
+                    custom_metric: null,
+                },
+                units: {
+                    weight: 'kg',
+                    distance: 'kilometers',
+                },
+                lokalizedLabels: {
+                    kg: 'kg',
+                    lbs: 'lbs',
+                    km: 'km',
+                    mi: 'mi',
+                    m: 'm',
+                    yd: 'yd',
+                    steps: 'Steps',
+                    floors: 'Floors',
+                },
+                exerciseType: 'weight_reps',
+            })).toBe('100 kg x 12');
+        });
+        it('formats weights logged in lbs', () => {
+            expect((0, utils_1.formatSetValue)({
+                set: {
+                    weight_kg: 50,
+                    reps: 12,
+                    duration_seconds: null,
+                    distance_meters: null,
+                    custom_metric: null,
+                },
+                units: {
+                    weight: 'lbs',
+                    distance: 'kilometers',
+                },
+                lokalizedLabels: {
+                    kg: 'kg',
+                    lbs: 'lbs',
+                    km: 'km',
+                    mi: 'mi',
+                    m: 'm',
+                    yd: 'yd',
+                    steps: 'Steps',
+                    floors: 'Floors',
+                },
+                exerciseType: 'weight_reps',
+            })).toBe('110.23 lbs x 12');
+        });
+        it('formats floors with duration', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'floors_duration' }))).toBe('15 Floors - 1min 30s');
+        });
+        it('formats steps with duration', () => {
+            expect((0, utils_1.formatSetValue)(Object.assign(Object.assign({}, baseParams), { exerciseType: 'steps_duration' }))).toBe('15 Steps - 1min 30s');
+        });
+    });
+    describe('distance', () => {
+        it('converts meters to kilometers and rounds to two decimals', () => {
+            expect((0, utils_1.distance)(1555, 'kilometers')).toBe(1.56);
+        });
+        it('converts meters to miles and rounds to two decimals', () => {
+            expect((0, utils_1.distance)(1000, 'miles')).toBe(0.62);
+        });
+    });
+    describe('exerciseWeight', () => {
+        it('returns rounded kg values for metric units', () => {
+            expect((0, utils_1.exerciseWeight)(10.555, 'kg')).toBe(10.56);
+        });
+        it('converts kg to lbs and rounds to two decimals', () => {
+            expect((0, utils_1.exerciseWeight)(100, 'lbs')).toBe(220.46);
+        });
+        it('rounds lbs values to two decimals', () => {
+            expect((0, utils_1.exerciseWeight)(4.535, 'lbs')).toBe(10.0);
+        });
+    });
 });