hevy-shared 1.0.962 → 1.0.963

package/built/utils.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExerciseTemplate = exports.isCompareExerciseSupported = exports.comparableExerciseTemplateIds = exports.numberWithCommas = exports.setVolume = exports.oneRepMax = exports.oneRepMaxPercentageMap = exports.workoutSetCount = exports.workoutDistanceMeters = exports.workoutReps = exports.workoutDurationSeconds = exports.removeAccents = exports.getClosestDataPointBeforeTargetDate = exports.stringToNumber = exports.forceStringToNumber = exports.formatDurationInput = exports.isValidFormattedTime = exports.customExerciseTemplateToExerciseTemplate = exports.isValidPhoneNumber = exports.isValidWebUrl = exports.isValidEmail = exports.secondsToWordFormatMinutes = exports.secondsToWordFormat = exports.secondsToClockFormat = exports.isValidUsername = exports.divide = exports.num = void 0;
+exports.calculateCurrentWeekStreak = exports.getYoutubeVideoId = exports.validateYoutubeUrl = exports.splitAtUsernamesAndLinks = exports.isVersionAGreaterOrEqualToVersionB = exports.generateUserGroupValue = exports.generateUserGroup = exports.isBaseExerciseTemplate = exports.getStrengthLevelFromPercentile = exports.numberToLocaleString = exports.numberWithCommas = exports.setVolume = exports.oneRepMax = exports.oneRepMaxPercentageMap = exports.getEstimatedExercisesDurationSeconds = exports.ESTIMATED_REST_TIMER_DURATION = exports.ESTIMATED_SET_DURATION = exports.UserFacingIndicatorToSetIndicator = exports.workoutSetCount = exports.userExerciseSetWeight = exports.workoutDistanceMeters = exports.workoutReps = exports.workoutDurationSeconds = exports.removeAccents = exports.getClosestDataPointAroundTargetDate = exports.getClosestDataPointBeforeTargetDate = exports.toFragmentedJSON = exports.findMapped = exports.stringToNumber = exports.forceStringToNumber = exports.formatDurationInput = exports.isValidFormattedTime = exports.isWholeNumber = exports.isNumber = exports.isValidUuid = exports.isValidPhoneNumber = exports.isValidWebUrl = exports.URL_REGEX = exports.isValidEmail = exports.secondsToWordFormatMinutes = exports.secondsToWordFormat = exports.secondsToClockFormat = exports.secondsToClockParts = exports.isValidUsername = exports.roundToWholeNumber = exports.roundToOneDecimal = exports.roundToTwoDecimal = exports.divide = exports.clampNumber = exports.num = void 0;
+exports.indexByNearestValue = exports.roundToKnownValue = exports.rawInstructionsToIndexedSteps = exports.formatSetValue = exports.exerciseWeight = exports.distance = exports.weekdayNumberMap = exports.startOfWeek = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const _1 = require(".");
 /**
  * Doesn't matter what you throw in the function it'll
  * always return a number. Non number values will return
@@ -12,26 +18,48 @@ const num = (value) => {
     return value !== null && value !== void 0 ? value : 0;
 };
 exports.num = num;
+const clampNumber = (value, limits) => {
+    var _a, _b;
+    const min = (_a = limits.min) !== null && _a !== void 0 ? _a : -Infinity;
+    const max = (_b = limits.max) !== null && _b !== void 0 ? _b : Infinity;
+    if (min > max) {
+        return NaN;
+    }
+    return Math.max(min, Math.min(max, value));
+};
+exports.clampNumber = clampNumber;
 const divide = (numerator, denominator) => {
     if (denominator === 0)
         return 0;
     return numerator / denominator;
 };
 exports.divide = divide;
+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 isValidUsername = (username) => {
     if (username.length > 20) {
         return false;
     }
-    const lowercase = username.toLowerCase();
-    if (lowercase.length < 3 ||
-        lowercase.startsWith('_') ||
-        lowercase.endsWith('_')) {
+    if (username.length < 3 ||
+        username.startsWith('_') ||
+        username.endsWith('_')) {
         return false;
     }
     const re = /^[a-z0-9_]+$/;
-    return re.test(lowercase);
+    return re.test(username);
 };
 exports.isValidUsername = isValidUsername;
+const secondsToClockParts = (totalSeconds) => {
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds - hours * 3600) / 60);
+    const seconds = totalSeconds - hours * 3600 - minutes * 60;
+    return { hours, minutes, seconds };
+};
+exports.secondsToClockParts = secondsToClockParts;
 /**
  * 01:25
  * 02:25:36
@@ -79,10 +107,12 @@ exports.secondsToWordFormat = secondsToWordFormat;
 /**
  * 14min
  * 2h 4min
+ * 2h 0min
  */
 const secondsToWordFormatMinutes = (seconds) => {
-    const hours = Math.floor(seconds / 3600);
-    const minutes = Math.floor((seconds - hours * 3600) / 60);
+    const totalMinutes = Math.round(seconds / 60);
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
     if (hours) {
         return `${hours}h ${minutes}min`;
     }
@@ -94,9 +124,32 @@ const isValidEmail = (email) => {
     return re.test(String(email).toLowerCase());
 };
 exports.isValidEmail = isValidEmail;
+/**
+ * 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://`
+ */
+exports.URL_REGEX = RegExp([
+    // optionally begin with http(s)://
+    /(https?:\/\/)?/,
+    // followed by the domain:
+    // - any combination of letters, numbers and dashes
+    // - but without a dash at the start or end
+    // - maximum 255 characters per domain
+    // - each domain ends with a `.`
+    /((?!-)[-a-z0-9]{1,255}(?<!-)\.)+/,
+    // followed by the top-level domain
+    /[a-z]{2,10}/,
+    // optionally followed by a path
+    /(\/[-a-z0-9@:%_+.~#?!&/=]*)?/,
+]
+    .map((r) => r.source)
+    .join(''));
 const isValidWebUrl = (url) => {
-    const re = /^(https?:\/\/)?(www\.)?[-a-z0-9.]{2,256}\.[a-z]{2,10}\b([-a-z0-9@:%_+.~#?&//=]*)$/;
-    return re.test(String(url).toLowerCase());
+    return RegExp(`^${exports.URL_REGEX.source}$`).test(String(url).toLowerCase());
 };
 exports.isValidWebUrl = isValidWebUrl;
 /**
@@ -118,21 +171,23 @@ const isValidPhoneNumber = (phoneNumber) => {
     return typeof phoneNumber === 'string' && /^\+\d{9,15}$/.test(phoneNumber);
 };
 exports.isValidPhoneNumber = isValidPhoneNumber;
-const customExerciseTemplateToExerciseTemplate = (cet) => ({
-    id: cet.id,
-    title: cet.title,
-    priority: 10,
-    muscle_group: cet.muscle_group,
-    other_muscles: cet.other_muscles || [],
-    exercise_type: cet.exercise_type,
-    equipment_category: cet.equipment_category,
-    is_custom: true,
-    is_archived: cet.is_archived,
-    custom_exercise_image_url: cet.custom_exercise_image_url,
-    thumbnail_url: cet.thumbnail_url,
-    parent_exercise_template_id: cet.parent_exercise_template_id,
-});
-exports.customExerciseTemplateToExerciseTemplate = customExerciseTemplateToExerciseTemplate;
+/**
+ * Matches all UUID types, case-insensitive (matches both uppercase and
+ * lowercase hexadecimal digits).
+ */
+const isValidUuid = (uuid) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return typeof uuid === 'string' && uuidRegex.test(uuid);
+};
+exports.isValidUuid = isValidUuid;
+const isNumber = (x) => {
+    return typeof x === 'number';
+};
+exports.isNumber = isNumber;
+const isWholeNumber = (value) => {
+    return value % 1 === 0;
+};
+exports.isWholeNumber = isWholeNumber;
 /**
  * Return true is value is of format: NN:NN or NN:NN:NN
  */
@@ -229,6 +284,77 @@ const stringToNumber = (value) => {
     return isNaN(numOrNaN) ? undefined : numOrNaN;
 };
 exports.stringToNumber = stringToNumber;
+/**
+ * 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.
+ */
+const findMapped = (array, transform) => {
+    for (const element of array) {
+        const result = transform(element);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+};
+exports.findMapped = findMapped;
+/**
+ * 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
+ */
+const toFragmentedJSON = (data, maxLength, options = { lengthIn: 'utf8bytes' }) => {
+    const outputArray = [];
+    const recurse = (left, right) => {
+        if (left === right)
+            return;
+        // slice the array and convert it to JSON
+        const sliceJson = JSON.stringify(data.slice(left, right));
+        const length = options.lengthIn === 'characters'
+            ? sliceJson.length
+            : Buffer.byteLength(sliceJson, 'utf8');
+        if (length <= maxLength) {
+            // the size is good, push the chunk to the output array
+            outputArray.push(sliceJson);
+        }
+        else if (right > left + 1) {
+            // there are at least 2 elements in the current slice
+            const middle = Math.ceil((left + right) / 2);
+            recurse(left, middle);
+            recurse(middle, right);
+        }
+        else {
+            // we can't subdivide any further but the string is still too long
+            throw new Error(`couldn't subdivide element`);
+        }
+    };
+    outputArray.length = 0;
+    recurse(0, data.length);
+    return outputArray;
+};
+exports.toFragmentedJSON = toFragmentedJSON;
+/**
+ * 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') }
+ */
 const getClosestDataPointBeforeTargetDate = (data, dateExtractor, targetDate) => {
     var _a;
     if (!data.length)
@@ -262,6 +388,37 @@ const getClosestDataPointBeforeTargetDate = (data, dateExtractor, targetDate) =>
     }
 };
 exports.getClosestDataPointBeforeTargetDate = getClosestDataPointBeforeTargetDate;
+/**
+ * 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') }
+ */
+const getClosestDataPointAroundTargetDate = (data, dateExtractor, targetDate) => {
+    if (!data.length)
+        return undefined;
+    return data.reduce((closest, current) => {
+        if (!closest)
+            return current;
+        const closestDiff = Math.abs(dateExtractor(closest).getTime() - targetDate.getTime());
+        const currentDiff = Math.abs(dateExtractor(current).getTime() - targetDate.getTime());
+        return currentDiff < closestDiff ? current : closest;
+    }, undefined);
+};
+exports.getClosestDataPointAroundTargetDate = getClosestDataPointAroundTargetDate;
 const removeAccents = (str) => {
     return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
 };
@@ -295,12 +452,84 @@ const workoutDistanceMeters = (workout) => {
     }, 0);
 };
 exports.workoutDistanceMeters = workoutDistanceMeters;
+/**
+ * Calculate the set weight for a given user exercise set
+ * to be used in the exercise stats calculations on the web and coach app
+ */
+const userExerciseSetWeight = (set, exerciseStore, hundredPercentBodyweightExercise) => {
+    if (!set)
+        return 0;
+    const exercise = exerciseStore.find((e) => e.id === set.exercise_template_id);
+    if (!exercise) {
+        return (0, exports.num)(set.weight_kg);
+    }
+    if (exercise.exercise_type === 'bodyweight_reps') {
+        return hundredPercentBodyweightExercise
+            ? (0, exports.num)(set.user_bodyweight_kg) + (0, exports.num)(set.weight_kg)
+            : (0, exports.num)(set.weight_kg);
+    }
+    else if (exercise.exercise_type === 'bodyweight_assisted_reps') {
+        return hundredPercentBodyweightExercise
+            ? Math.max((0, exports.num)(set.user_bodyweight_kg) - (0, exports.num)(set.weight_kg), 0)
+            : 0;
+    }
+    else if (exercise.exercise_type === 'reps_only') {
+        return hundredPercentBodyweightExercise ? (0, exports.num)(set.user_bodyweight_kg) : 0;
+    }
+    else {
+        return (0, exports.num)(set.weight_kg);
+    }
+};
+exports.userExerciseSetWeight = userExerciseSetWeight;
 const workoutSetCount = (w) => {
     return w.exercises.reduce((accu, exercise) => {
         return accu + exercise.sets.length;
     }, 0);
 };
 exports.workoutSetCount = workoutSetCount;
+const UserFacingIndicatorToSetIndicator = (indicator) => {
+    switch (indicator) {
+        case 'dropset':
+            return 'dropset';
+        case 'warmup':
+            return 'warmup';
+        case 'failure':
+            return 'failure';
+        default:
+            return 'normal';
+    }
+};
+exports.UserFacingIndicatorToSetIndicator = UserFacingIndicatorToSetIndicator;
+exports.ESTIMATED_SET_DURATION = 45;
+exports.ESTIMATED_REST_TIMER_DURATION = 90;
+const isDurationExercise = (type) => {
+    return (type === 'duration' ||
+        type === 'weight_duration' ||
+        type === 'distance_duration' ||
+        type === 'floors_duration' ||
+        type === 'steps_duration');
+};
+const getEstimatedExercisesDurationSeconds = ({ exercises, }) => {
+    const totalSeconds = exercises.reduce((exercisesTotal, exercise) => {
+        var _a;
+        const restPerSet = (_a = exercise.rest_seconds) !== null && _a !== void 0 ? _a : exports.ESTIMATED_REST_TIMER_DURATION;
+        const setsTotal = exercise.sets.reduce((setTotal, set) => {
+            var _a;
+            // Sometimes we get 0 values for duration on exercises that aren't duration.
+            // Added this check to prevent having a estimated duration of 0 for these.
+            const duration = isDurationExercise(exercise.exercise_type)
+                ? (_a = set.duration_seconds) !== null && _a !== void 0 ? _a : exports.ESTIMATED_SET_DURATION
+                : exports.ESTIMATED_SET_DURATION;
+            // if it is a dropset, we don't add the rest time
+            if (set.indicator === 'dropset')
+                return setTotal + duration;
+            return setTotal + duration + restPerSet;
+        }, 0);
+        return exercisesTotal + setsTotal;
+    }, 0);
+    return totalSeconds;
+};
+exports.getEstimatedExercisesDurationSeconds = getEstimatedExercisesDurationSeconds;
 exports.oneRepMaxPercentageMap = {
     1: 1.0,
     2: 0.97,
@@ -345,73 +574,357 @@ const setVolume = (weight, reps) => {
     return weight * reps;
 };
 exports.setVolume = setVolume;
+/** @deprecated use `numberToLocaleString` */
 const numberWithCommas = (x) => {
     return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
 };
 exports.numberWithCommas = numberWithCommas;
-exports.comparableExerciseTemplateIds = new Set([
-    '79D0BB3A' /* Bench Press (Barbell) **/,
-    'D04AC939' /* Squat (Barbell) **/,
-    'A5AC6449' /* Bicep Curl (Barbell) **/,
-    '5F4E6DD3' /* Deadlift (Barbell) **/,
-    'D20D7BBE' /* Sumo Deadlift **/,
-    '50DFDFAB' /* Incline Bench (Barbell) **/,
-    '55E6546F' /* Penlay Row **/,
-    'C6272009' /* Deadlift (Barbell) **/,
-    '7B8D84E8' /* Overhead Press (Barbell) **/,
-    'C7973E0E' /* Leg Press **/,
-    'DA0F0470' /* Decline Bench (Barbell) **/,
-    '5046D0A9' /* Front Squat **/,
-    '1283BBA6' /* Full Squat **/,
-    '6622E5A0' /* Sumo Squat (Barbell) **/,
-    'FE389074' /* Rack Pull **/,
-    '92B8C7E1' /* Hip Thrust **/,
-    '1B2B1E7C' /* Pull Up **/,
-    '392887AA' /* Push Up **/,
-    '29083183' /* Chin Up **/,
-    '7AB9A362' /* Upright Row (Barbell) **/,
-    '90E506D5' /* Thruster (Barbell) **/,
-    '2A48E443' /* Straight Leg Deadlift **/,
-    '073032BB' /* Standing Military Press (Barbell) **/,
-    '9694DA61' /* Squat (Bodyweight) **/,
-    'FB09C938' /* Snatch **/,
-    '875F585F' /* Skullcrusher (Barbell) **/,
-    '022DF610' /* Sit Up **/,
-    '0B841777' /* Shrug (Barbell) **/,
-    '91AF29E0' /* Seated Overhead Press (Barbell) **/,
-    '2B4B7310' /* Romanian Deadlift (Barbell) **/,
-    '818BA121' /* Reverse Lunge (Barbell) **/,
-    '542F3CD5' /* Push Press **/,
-    'E22F9358' /* Power Snatch **/,
-    'C628D768' /* Power Clean **/,
-    '3FF6A22E' /* Pistol Squat **/,
-    '0EFE8162' /* Pike Pushup **/,
-    '018ADC12' /* Pendlay Row (Barbell) **/,
-    '6E6EE645' /* Lunge (Barbell) **/,
-    '5E1A7777' /* Lunge **/,
-    'B74A95BB' /* Kneeling Push Up **/,
-    '70D4EBBF' /* Jump Squat **/,
-    'D57C2EC7' /* Hip Thrust (Barbell) **/,
-    '4180C405' /* Good Morning (Barbell) **/,
-    '6575F52D' /* Diamond Push Up **/,
-    'DCF3B31B' /* Crunch **/,
-    '652FEA39' /* Clean Pull **/,
-    'D3095577' /* Clean and Press **/,
-    '9E09CEC3' /* Clean and Jerk **/,
-    'ABB00838' /* Clean **/,
-    'BB792A36' /* Burpee **/,
-    'E644F828' /* Bench Press - Wide Grip (Barbell) **/,
-    '35B51B87' /* Bench Press - Close Grip (Barbell) **/,
-]);
-const isCompareExerciseSupported = (temlpateId) => {
-    return exports.comparableExerciseTemplateIds.has(temlpateId);
-};
-exports.isCompareExerciseSupported = isCompareExerciseSupported;
-const isExerciseTemplate = (x) => {
+/**
+ * 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)
+ */
+const numberToLocaleString = (value, options) => value.toLocaleString(undefined, Object.assign({}, options));
+exports.numberToLocaleString = numberToLocaleString;
+const getStrengthLevelFromPercentile = (percentile) => {
+    if (percentile >= 90) {
+        return 'elite';
+    }
+    else if (percentile >= 70) {
+        return 'advanced';
+    }
+    else if (percentile >= 40) {
+        return 'intermediate';
+    }
+    else {
+        return 'beginner';
+    }
+};
+exports.getStrengthLevelFromPercentile = getStrengthLevelFromPercentile;
+const isBaseExerciseTemplate = (x) => {
     return (x.id !== undefined &&
         x.title !== undefined &&
         x.muscle_group !== undefined &&
         x.exercise_type !== undefined &&
         x.equipment_category !== undefined);
 };
-exports.isExerciseTemplate = isExerciseTemplate;
+exports.isBaseExerciseTemplate = isBaseExerciseTemplate;
+const _v4uuidCheckRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-([0-9a-f])[0-9a-f]{3}-([0-9a-f])[0-9a-f]{3}-([0-9a-f]{12})/i;
+/**
+ * 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
+ */
+const generateUserGroup = (userId, numGroups) => {
+    if (numGroups < 2 || numGroups > 2 ** 32) {
+        return { isSuccess: false, error: 'invalid-number-of-groups' };
+    }
+    const match = _v4uuidCheckRegex.exec(userId);
+    if (!match) {
+        return { isSuccess: false, error: 'invalid-uuid' };
+    }
+    const [, version, variant, tail] = match;
+    if (version !== '4') {
+        return { isSuccess: false, error: 'uuid-not-v4' };
+    }
+    if (!['8', '9', 'a', 'b', 'c', 'd'].includes(variant.toLowerCase())) {
+        return { isSuccess: false, error: 'invalid-variant' };
+    }
+    let value;
+    try {
+        const idHexString = `0x${tail}`;
+        const idBigInt = BigInt(idHexString);
+        const numGroupsBigInt = BigInt(numGroups);
+        const remainderBigInt = idBigInt % numGroupsBigInt;
+        value = Number(remainderBigInt);
+    }
+    catch (e) {
+        throw new Error(`generateUserGroup: tail="${tail}": ${e === null || e === void 0 ? void 0 : e.message}`);
+    }
+    return { isSuccess: true, value };
+};
+exports.generateUserGroup = generateUserGroup;
+/**
+ * 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.
+ */
+const generateUserGroupValue = (userId, numGroups) => {
+    const group = (0, exports.generateUserGroup)(userId, numGroups);
+    if (group.isSuccess) {
+        switch (group.value) {
+            case 0:
+                return 'A';
+            case 1:
+                return 'B';
+            case 2:
+                return 'C';
+            case 3:
+                return 'D';
+            case 4:
+                return 'E';
+            case 5:
+                return 'F';
+            case 6:
+                return 'G';
+            case 7:
+                return 'H';
+            case 8:
+                return 'I';
+            case 9:
+                return 'J';
+            default:
+                return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+};
+exports.generateUserGroupValue = generateUserGroupValue;
+/**
+ * @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
+ */
+const isVersionAGreaterOrEqualToVersionB = (versionA, versionB) => {
+    var _a, _b;
+    const versionAparts = `${versionA}`.split('.');
+    const versionBparts = `${versionB}`.split('.');
+    const longestVersionLength = Math.max(versionAparts.length, versionBparts.length);
+    for (let i = 0; i < longestVersionLength; i++) {
+        const versionApart = (_a = versionAparts[i]) !== null && _a !== void 0 ? _a : 0;
+        const versionBpart = (_b = versionBparts[i]) !== null && _b !== void 0 ? _b : 0;
+        if (parseInt(versionApart, 10) > parseInt(versionBpart, 10)) {
+            return true;
+        }
+        if (parseInt(versionApart, 10) < parseInt(versionBpart, 10)) {
+            return false;
+        }
+        // if equal, continue to next part
+    }
+    // the versions are entirely equal
+    return true;
+};
+exports.isVersionAGreaterOrEqualToVersionB = isVersionAGreaterOrEqualToVersionB;
+const splitAtUsernamesAndLinks = (text) => {
+    const mentionsRegex = /\B@[a-z0-9_-]+/gi;
+    const linksRegex = exports.URL_REGEX;
+    const regex = new RegExp(`(${mentionsRegex.source}|${linksRegex.source})`, 'gi');
+    const matches = text.match(regex);
+    const format = [];
+    if (!matches) {
+        return [{ format: 'none', text }];
+    }
+    let lastIndex = 0;
+    matches.forEach((match) => {
+        const index = text.indexOf(match, lastIndex);
+        if (index > lastIndex) {
+            format.push({ format: 'none', text: text.substring(lastIndex, index) });
+        }
+        if (match.match(linksRegex)) {
+            format.push({ format: 'link', text: match });
+        }
+        else if (match.match(mentionsRegex)) {
+            format.push({ format: '@', text: match });
+        }
+        lastIndex = index + match.length;
+    });
+    if (lastIndex < text.length) {
+        format.push({ format: 'none', text: text.substring(lastIndex) });
+    }
+    return format;
+};
+exports.splitAtUsernamesAndLinks = splitAtUsernamesAndLinks;
+// Single comprehensive YouTube URL regex for both validation and ID extraction
+const YOUTUBE_URL_REGEX = /^(?:https?:\/\/)?(?:(?:www\.)?youtube\.com\/(?:watch\?v=|shorts\/|embed\/|v\/|user\/[^/]+#p\/|attribution_link\?a=|channel\/|c\/|playlist\?list=)|youtu\.be\/)([a-zA-Z0-9_-]{11})(?:[/?#&].*)?$/;
+const validateYoutubeUrl = (url) => {
+    return YOUTUBE_URL_REGEX.test(url);
+};
+exports.validateYoutubeUrl = validateYoutubeUrl;
+const getYoutubeVideoId = (url) => {
+    const match = url.match(YOUTUBE_URL_REGEX);
+    return match && match[1] && match[1].length === 11 ? match[1] : undefined;
+};
+exports.getYoutubeVideoId = getYoutubeVideoId;
+/**@param workouts must be sorted descending by start_time */
+const calculateCurrentWeekStreak = (workouts, firstWeekday, untilUnix = (0, dayjs_1.default)().unix()) => {
+    let streakCount = 0;
+    let weekStart = (0, exports.startOfWeek)(dayjs_1.default.unix(untilUnix), firstWeekday).subtract(1, 'week');
+    let weekEnd = weekStart.add(1, 'week');
+    let i = 0;
+    /** Iterate through the workouts from most recent to least and keep track of the week-long
+     * sliding window in which there needs to be a workout present in order for the streak to count.
+     * If there is a workout present during this window, move the window into the past by a week
+     * and keep iterating through the workouts. If there are no workouts during this window,
+     * the streak count is not incremented.
+     */
+    while (i < workouts.length) {
+        const workoutStart = workouts[i].start_time;
+        if (workoutStart >= weekStart.unix() && workoutStart <= weekEnd.unix()) {
+            streakCount += 1;
+            weekStart = weekStart.subtract(1, 'week');
+            weekEnd = weekEnd.subtract(1, 'week');
+        }
+        else if (workoutStart < weekStart.unix()) {
+            /** This workout is before the sliding window. We don't get to this point unless
+             * the user didn't workout during the window. So that means the streak is over
+             */
+            break;
+        }
+        i += 1;
+    }
+    // check if the current week has any workouts
+    weekStart = (0, exports.startOfWeek)(dayjs_1.default.unix(untilUnix), firstWeekday);
+    weekEnd = weekStart.add(1, 'week');
+    if (workouts.find(({ start_time }) => start_time >= weekStart.unix() && start_time <= weekEnd.unix())) {
+        streakCount += 1;
+    }
+    return streakCount;
+};
+exports.calculateCurrentWeekStreak = calculateCurrentWeekStreak;
+const startOfWeek = (d, firstDayOfWeek) => {
+    const firstDayOfWeekIndex = exports.weekdayNumberMap[firstDayOfWeek];
+    let testDay = d;
+    while (testDay.day() !== firstDayOfWeekIndex) {
+        testDay = testDay.subtract(1, 'day');
+    }
+    return testDay.startOf('day');
+};
+exports.startOfWeek = startOfWeek;
+exports.weekdayNumberMap = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6,
+};
+const distance = (value, distanceUnit) => {
+    if (distanceUnit === 'miles') {
+        const unrounded = (0, _1.exactMetersToMiles)(value);
+        return (0, exports.roundToTwoDecimal)(unrounded);
+    }
+    return (0, exports.roundToTwoDecimal)(value / 1000);
+};
+exports.distance = distance;
+const exerciseWeight = (value, weightUnit) => {
+    if (weightUnit === 'lbs') {
+        return (0, exports.roundToTwoDecimal)((0, _1.exactKgtoLbs)(value));
+    }
+    return (0, exports.roundToTwoDecimal)(value);
+};
+exports.exerciseWeight = exerciseWeight;
+const formatSetValue = ({ exerciseType, set, units, lokalizedLabels, }) => {
+    var _a, _b, _c;
+    const unitToLabelMap = {
+        kg: lokalizedLabels.kg,
+        lbs: lokalizedLabels.lbs,
+        km: lokalizedLabels.km,
+        mi: lokalizedLabels.mi,
+        m: lokalizedLabels.m,
+        yd: lokalizedLabels.yd,
+        steps: lokalizedLabels.steps,
+        floors: lokalizedLabels.floors,
+    };
+    switch (exerciseType) {
+        case 'weight_reps':
+        case 'bodyweight_reps': {
+            const weight = `${(0, exports.exerciseWeight)(set.weight_kg || 0, units.weight)} ${unitToLabelMap[units.weight]}`;
+            const reps = `${(_a = set.reps) !== null && _a !== void 0 ? _a : 0}`;
+            return `${weight} x ${reps}`;
+        }
+        case 'bodyweight_assisted_reps': {
+            const weight = `-${(0, exports.exerciseWeight)(set.weight_kg || 0, units.weight)} ${unitToLabelMap[units.weight]}`;
+            const reps = `${(_b = set.reps) !== null && _b !== void 0 ? _b : 0}`;
+            return `${weight} x ${reps}`;
+        }
+        case 'reps_only':
+            return `${(_c = set.reps) !== null && _c !== void 0 ? _c : 0}`;
+        case 'distance_duration': {
+            const distanceUnitShort = units.distance === 'kilometers' ? 'km' : 'mi';
+            const distanceValue = `${(0, exports.distance)(set.distance_meters || 0, units.distance)} ${unitToLabelMap[distanceUnitShort]}`;
+            const duration = `${(0, exports.secondsToWordFormat)(Number(set.duration_seconds))}`;
+            return `${distanceValue} - ${duration}`;
+        }
+        case 'duration':
+            return (0, exports.secondsToWordFormat)(Number(set.duration_seconds));
+        case 'short_distance_weight': {
+            const weight = `${(0, exports.exerciseWeight)(set.weight_kg || 0, units.weight)} ${unitToLabelMap[units.weight]}`;
+            const shortDistance = (0, exports.roundToTwoDecimal)(set.distance_meters || 0);
+            const shortDistanceUnitShort = units.distance === 'kilometers' ? 'm' : 'yd';
+            const shortDistanceUnitShortLabel = unitToLabelMap[shortDistanceUnitShort];
+            return `${weight} - ${shortDistance} ${shortDistanceUnitShortLabel}`;
+        }
+        case 'weight_duration': {
+            const weight = `${(0, exports.exerciseWeight)(set.weight_kg || 0, units.weight)} ${unitToLabelMap[units.weight]}`;
+            const duration = `${(0, exports.secondsToWordFormat)(Number(set.duration_seconds))}`;
+            return `${weight} - ${duration}`;
+        }
+        case 'floors_duration':
+            return `${set.custom_metric ? (0, exports.roundToWholeNumber)(set.custom_metric) : 0} ${unitToLabelMap.floors} - ${(0, exports.secondsToWordFormat)(Number(set.duration_seconds))}`;
+        case 'steps_duration':
+            return `${set.custom_metric ? (0, exports.roundToWholeNumber)(set.custom_metric) : 0} ${unitToLabelMap.steps} - ${(0, exports.secondsToWordFormat)(Number(set.duration_seconds))}`;
+        default:
+            (0, _1.exhaustiveTypeCheck)(exerciseType);
+            return '';
+    }
+};
+exports.formatSetValue = formatSetValue;
+const rawInstructionsToIndexedSteps = (rawInstructions) => {
+    const instructionsByLine = rawInstructions
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    const instructionsByStep = instructionsByLine.map((s) => {
+        var _a, _b;
+        const parsedStep = s.match(/^([0-9]*)\\?\.(.*)$/);
+        if (!parsedStep) {
+            // this line doesn't contain a number, so just return it unchanged
+            return { description: s };
+        }
+        const index = Number(parsedStep[1]) || undefined; // if it's NaN or 0, convert it to undefined
+        const description = (_b = (_a = parsedStep[2]) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : s;
+        return { index, description };
+    });
+    return instructionsByStep;
+};
+exports.rawInstructionsToIndexedSteps = rawInstructionsToIndexedSteps;
+const roundToKnownValue = (value, knownValues) => {
+    if (knownValues.length === 0)
+        return undefined;
+    const boundingValues = knownValues.reduce(([lower, upper], v) => {
+        return [
+            v > lower && v <= value ? v : lower,
+            v < upper && v >= value ? v : upper,
+        ];
+    }, [-Infinity, Infinity]);
+    if (boundingValues[0] === -Infinity && boundingValues[1] === Infinity)
+        return undefined;
+    if (boundingValues[0] === -Infinity)
+        return boundingValues[1];
+    if (boundingValues[1] === Infinity)
+        return boundingValues[0];
+    return value - boundingValues[0] < boundingValues[1] - value
+        ? boundingValues[0]
+        : boundingValues[1];
+};
+exports.roundToKnownValue = roundToKnownValue;
+const indexByNearestValue = (value, map) => {
+    const index = (0, exports.roundToKnownValue)(value, Object.keys(map).map((e) => Number(e)));
+    return index ? map[index] : undefined;
+};
+exports.indexByNearestValue = indexByNearestValue;