hevy-shared 1.0.962 → 1.0.963

package/built/adjustEventTokens.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADJUST_EVENT_TOKENS = void 0;
+/**
+ * Manage adjust events at https://suite.adjust.com/apps/na3q7q6avq4g/events
+ */
+exports.ADJUST_EVENT_TOKENS = {
+    logWorkout: 'e3xe9l',
+    purchase: 'qf1l8r',
+    signupComplete: 'n46d1z',
+    renewal: 'i5pcdz',
+    updateSexMale: 'kbdp5b',
+    updateSexFemale: 'jkkjka',
+    updateSexOther: 'z4awr3',
+    updateAge18Through28: 'o5f1gc',
+    updateAge29Through44: 'vvhb17',
+    updateAge45AndUp: '3meyo6',
+};

package/built/adminPermissions.d.ts

@@ -0,0 +1,4 @@
+import { Lookup } from './typeUtils';
+export declare const AdminPermissions: readonly ["become_user", "blacklists", "featured_users", "feature_flags", "hevy_trainer", "user_account_management", "import_strong_csv", "community_management", "user_app_logs", "backend_maintenance"];
+export type AdminPermission = Lookup<typeof AdminPermissions>;
+export declare const isAdminPermission: (permission?: any) => permission is AdminPermission;

package/built/adminPermissions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAdminPermission = exports.AdminPermissions = void 0;
+exports.AdminPermissions = [
+    'become_user',
+    'blacklists',
+    'featured_users',
+    'feature_flags',
+    'hevy_trainer',
+    'user_account_management',
+    'import_strong_csv',
+    'community_management',
+    'user_app_logs',
+    'backend_maintenance',
+];
+const isAdminPermission = (permission) => {
+    if (!permission || typeof permission !== 'string') {
+        return false;
+    }
+    return exports.AdminPermissions.includes(permission);
+};
+exports.isAdminPermission = isAdminPermission;

package/built/async.d.ts

@@ -0,0 +1,50 @@
+export type Result<T, E = unknown> = {
+    isSuccess: true;
+    value: T;
+} | {
+    isSuccess: false;
+    error: E;
+};
+/**
+ * The difference between this and `Promise.all` is that `Promise.all` rejects
+ * when any promise rejects, and this resolves when all promises resolve _or_
+ * reject.
+ *
+ * This function returns an array of results, each of which is either a success
+ * result containing the resolved promise, or an error result containing the
+ * value that was passed to `reject()`.
+ *
+ * This function itself never throws or rejects.
+ */
+export declare const allToResolveOrReject: <T>(promises: Promise<T>[]) => Promise<Result<T>[]>;
+/**
+ * Attach a dummy rejection handler to a promise and return the original
+ * promise. Used to prevent unhandled rejections in the background.
+ *
+ * To use this, wrap any `async` or `Promise`-returning function with this
+ * function and use it as you otherwise would.
+ *
+ * Calling this multiple times for the same promise should have no ill effect.
+ *
+ * @example
+ * // Before
+ * await fetch('https://hevy.com/blabla');
+ *
+ * // After
+ * await handleRejection(fetch('https://hevy.com/blabla'));
+ */
+export declare const handleRejection: <T>(p: Promise<T>) => Promise<T>;
+type Stage3MethodDecorator<T> = (value: (...args: any[]) => T, context: ClassMemberDecoratorContext) => (...args: any[]) => T;
+export declare function _synchronized_3(queue: boolean): Stage3MethodDecorator<Promise<any>>;
+export declare function _synchronized_3(queue: boolean, id: any): Stage3MethodDecorator<Promise<any>>;
+export declare function _synchronized_3(value: (...args: any[]) => any, context: ClassMemberDecoratorContext): void;
+type LegacyMethodDecorator<T> = (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => T>) => void;
+export declare function synchronized(queue: boolean): LegacyMethodDecorator<Promise<any>>;
+export declare function synchronized(queue: boolean, id: any): LegacyMethodDecorator<Promise<any>>;
+export declare function synchronized(target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>): void;
+export declare abstract class LockError extends Error {
+    abstract readonly propertyKey: string | symbol;
+    abstract readonly lockId: unknown;
+    protected constructor(...args: any);
+}
+export {};

package/built/async.js

@@ -0,0 +1,170 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockError = exports.handleRejection = exports.allToResolveOrReject = void 0;
+exports._synchronized_3 = _synchronized_3;
+exports.synchronized = synchronized;
+/**
+ * The difference between this and `Promise.all` is that `Promise.all` rejects
+ * when any promise rejects, and this resolves when all promises resolve _or_
+ * reject.
+ *
+ * This function returns an array of results, each of which is either a success
+ * result containing the resolved promise, or an error result containing the
+ * value that was passed to `reject()`.
+ *
+ * This function itself never throws or rejects.
+ */
+const allToResolveOrReject = (promises) => __awaiter(void 0, void 0, void 0, function* () {
+    // Attach a dummy rejection handler to each promise as soon as possible, to
+    // try to prevent them from rejecting in the background without a handler, as
+    // that can cause issues, depending on the runtime environment.
+    //
+    promises.forEach(exports.handleRejection); // try to comment this out & run the tests
+    const results = [];
+    for (const promise of promises) {
+        try {
+            const value = yield promise;
+            results.push({ isSuccess: true, value });
+        }
+        catch (error) {
+            results.push({ isSuccess: false, error });
+        }
+    }
+    return results;
+});
+exports.allToResolveOrReject = allToResolveOrReject;
+/**
+ * Attach a dummy rejection handler to a promise and return the original
+ * promise. Used to prevent unhandled rejections in the background.
+ *
+ * To use this, wrap any `async` or `Promise`-returning function with this
+ * function and use it as you otherwise would.
+ *
+ * Calling this multiple times for the same promise should have no ill effect.
+ *
+ * @example
+ * // Before
+ * await fetch('https://hevy.com/blabla');
+ *
+ * // After
+ * await handleRejection(fetch('https://hevy.com/blabla'));
+ */
+const handleRejection = (p) => (p.catch(() => { }), p);
+exports.handleRejection = handleRejection;
+/**
+ * Do not use this directly. Use the alias provided by the parent project.
+ */
+function _synchronized_3(arg0, arg1) {
+    if (typeof arg1 === 'object' &&
+        arg1 !== null &&
+        'name' in arg1 &&
+        'access' in arg1) {
+        return synchronizedStage3DecoratorFactory(arg0, arg1, true);
+    }
+    else {
+        return function (value, context) {
+            return synchronizedStage3DecoratorFactory(value, context, arg0, arg1);
+        };
+    }
+}
+function synchronized(arg0, arg1, arg2) {
+    if (arguments.length === 1) {
+        return function (target, propertyKey, descriptor) {
+            return synchronizedLegacyDecoratorFactory(target, propertyKey, descriptor, arg0);
+        };
+    }
+    else if (arguments.length === 2) {
+        return function (target, propertyKey, descriptor) {
+            return synchronizedLegacyDecoratorFactory(target, propertyKey, descriptor, arg0, arg1);
+        };
+    }
+    else {
+        return synchronizedLegacyDecoratorFactory(arg0, arg1, arg2, true);
+    }
+}
+const $queue = Symbol();
+class LockError extends Error {
+    constructor(...args) {
+        super(...args);
+    }
+}
+exports.LockError = LockError;
+class $LockError extends LockError {
+    constructor({ message: baseMessage, propertyKey, lockId, }) {
+        const formattedLockId = lockId !== undefined ? `"${String(lockId)}"` : '(anonymous)';
+        const message = `Cannot invoke "${String(propertyKey)}" (locked by ${formattedLockId}): ${baseMessage}`;
+        super(message);
+        this.name = 'LockError';
+        this.message = message;
+        this.propertyKey = propertyKey;
+        this.lockId = lockId;
+    }
+}
+function synchronizedStage3DecoratorFactory(origFn, context, wait, id) {
+    const lockId = arguments.length === 4 ? id : Symbol();
+    const propertyKey = context.name;
+    return synchronizedDecoratorFactory({
+        id,
+        lockId,
+        origFn,
+        propertyKey,
+        wait,
+    });
+}
+function synchronizedLegacyDecoratorFactory(_target, propertyKey, descriptor, wait, id) {
+    const origFn = descriptor.value;
+    const lockId = arguments.length === 5 ? id : Symbol();
+    descriptor.value = synchronizedDecoratorFactory({
+        id,
+        lockId,
+        origFn,
+        propertyKey,
+        wait,
+    });
+}
+function synchronizedDecoratorFactory({ id, lockId, origFn, propertyKey, wait, }) {
+    return function (...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            var _c;
+            const queue = ((_b = (_c = ((_a = this[$queue]) !== null && _a !== void 0 ? _a : (this[$queue] = {})))[lockId]) !== null && _b !== void 0 ? _b : (_c[lockId] = []));
+            if (queue.length > 0 && !wait) {
+                throw new $LockError({
+                    message: 'Operation is already in progress',
+                    propertyKey,
+                    lockId: id,
+                });
+            }
+            let done;
+            const thisCall = new Promise((resolve) => {
+                done = resolve;
+            });
+            const waiting = [...queue];
+            queue.push(thisCall);
+            yield (0, exports.allToResolveOrReject)(waiting);
+            try {
+                return yield origFn.apply(this, args);
+            }
+            finally {
+                done();
+                if (queue.shift() !== thisCall) {
+                    // eslint-disable-next-line no-unsafe-finally
+                    throw new $LockError({
+                        message: 'Assertion failed: @synchronized queue is mangled',
+                        propertyKey,
+                        lockId: id,
+                    });
+                }
+            }
+        });
+    };
+}

package/built/chat.d.ts

@@ -6,7 +6,15 @@ export interface PostCreateConversationResponse {
 }
 export interface PostMessageRequest {
     conversation_id: string;
-    data: CreateTextMessageData | CreateNewWorkoutMessageData | CreateNewBodyMeasurementMesageData;
+    data: CreateTextMessageData | CreateVideoMessageData | CreateImageMessageData;
+}
+export interface PostGetDeletedMessagesRequest {
+    messages_deleted_since_time?: string;
+    conversation_id: string;
+}
+export interface PostDeletedMessagesResponse {
+    deleted_message_ids: string[];
+    checked_at_time: string;
 }
 export interface PostMessageResponse {
     message_id: string;
@@ -15,13 +23,13 @@ export interface CreateTextMessageData {
     type: 'text';
     text: string;
 }
-export interface CreateNewWorkoutMessageData {
-    type: 'new-workout';
-    workout_id: string;
+export interface CreateVideoMessageData {
+    type: 'video';
+    video_url: string;
 }
-export interface CreateNewBodyMeasurementMesageData {
-    type: 'new-body-measurement';
-    measurement_id: number;
+export interface CreateImageMessageData {
+    type: 'image';
+    image_url: string;
 }
 export interface GetLatestMessageFromAllClientsResponse {
     conversations: {
@@ -48,7 +56,7 @@ export interface Conversation {
     conversation_id: string;
     user_ids: string[];
 }
-export type MessageType = 'text' | 'new-workout' | 'new-body-measurement';
+export type MessageType = 'text' | 'video' | 'image';
 export interface MessageBase {
     id: string;
     sender_user_id: string;
@@ -60,21 +68,15 @@ export interface TextMessage extends MessageBase {
     type: 'text';
     text: string;
 }
-export interface NewWorkoutMessageData {
-    workout_id: string;
-}
-export interface NewWorkoutMessage extends MessageBase {
-    type: 'new-workout';
-    data: NewWorkoutMessageData;
-}
-export interface NewBodyMeasurementMessageData {
-    measurement_id: number;
+export interface VideoMessage extends MessageBase {
+    type: 'video';
+    video_url: string;
 }
-export interface NewBodyMeasurementMessage extends MessageBase {
-    type: 'new-body-measurement';
-    data: NewBodyMeasurementMessageData;
+export interface ImageMessage extends MessageBase {
+    type: 'image';
+    image_url: string;
 }
-export type Message = TextMessage | NewWorkoutMessage | NewBodyMeasurementMessage;
+export type Message = TextMessage | VideoMessage | ImageMessage;
 export declare const isMessage: (message?: any) => message is Message;
 export interface NewMessageChatUpdate {
     type: 'new-message';
@@ -89,5 +91,5 @@ export interface NewConversationChatUpdate {
     conversation_id: string;
     conversation_users: string[];
 }
-export type HevyChatUpdatePush = NewMessageChatUpdate | MessageDeletedChatUpdate | NewConversationChatUpdate;
-export declare const isHevyChatUpdatePush: (message?: any) => message is HevyChatUpdatePush;
+export type HevyChatUpdateMobilePushData = NewMessageChatUpdate | MessageDeletedChatUpdate | NewConversationChatUpdate;
+export declare const isHevyChatUpdatePush: (message?: any) => message is HevyChatUpdateMobilePushData;

package/built/coachPlans.d.ts

@@ -1,10 +1,11 @@
 export declare const HevyCoachDefaultPlan: Plan;
-export type PlanType = 'default' | 'paid_paddle' | 'trial' | 'beta';
+export type PlanType = 'none' | 'paid_paddle' | 'trial' | 'beta';
 export interface Plan {
     title: string;
     maximum_clients: number;
     id: string;
     paddle_update_payment_url?: string;
+    paddle_subscription_id?: number;
     renewal_period: 'monthly' | 'lifetime';
     renewal_price?: string;
     renewal_currency?: string;

package/built/coachPlans.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HevyCoachDefaultPlan = void 0;
 exports.HevyCoachDefaultPlan = {
-    maximum_clients: 3,
+    maximum_clients: 0,
     id: 'hevy_coach_free',
     title: 'Free',
     renewal_period: 'lifetime',
-    type: 'default',
+    type: 'none',
 };

package/built/cue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A = control group
+ *
+ * B = test group
+ */
+export type CueGroup = 'a' | 'b';
+/**
+ * A = control group
+ *
+ * B = test group
+ */
+export declare const generateCueGroup: (userId: string) => CueGroup | undefined;

package/built/cue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCueGroup = void 0;
+/**
+ * A = control group
+ *
+ * B = test group
+ */
+const generateCueGroup = (userId) => {
+    if (typeof userId !== 'string') {
+        return undefined;
+    }
+    const firstCharacter = userId.charAt(0);
+    if (['0', '1', '2', '3', '4', '5', '6', '7'].includes(firstCharacter)) {
+        return 'a';
+    }
+    if (['8', '9', 'a', 'b', 'c', 'd', 'e', 'f'].includes(firstCharacter)) {
+        return 'b';
+    }
+    return undefined;
+};
+exports.generateCueGroup = generateCueGroup;

package/built/exerciseLocaleUtils.d.ts

@@ -0,0 +1,17 @@
+import { LibraryExercise, Lookup } from '.';
+import { Language } from './translations';
+/** Keeping exercise instruction/title localization utils here instead of translations
+ * so I don't need to import exercise types from here in translations (translations was
+ * created so that hevy-web can import utils from shared without importing something from
+ * that isn't allowed in Edge Runtime)
+ */
+export declare const supportedInstructionsLanguages: readonly ["en", "it", "de", "es", "fr", "pt"];
+export type InstructionsLanguage = Lookup<typeof supportedInstructionsLanguages>;
+export declare const isSupportedInstructionsLanguage: (lang: string) => lang is InstructionsLanguage;
+type LocalizableExerciseTemplate = Pick<LibraryExercise, 'title' | 'es_title' | 'de_title' | 'fr_title' | 'it_title' | 'ja_title' | 'ko_title' | 'pt_title' | 'ru_title' | 'tr_title' | 'zh_cn_title' | 'zh_tw_title' | 'localised_instructions' | 'is_custom'>;
+export declare const localisedExerciseTitle: (locale: Language, template: LocalizableExerciseTemplate) => string;
+export declare const localisedExerciseInstructions: (locale: Language, exerciseTemplate: LocalizableExerciseTemplate) => string;
+export declare const localeSelect: <T>(locale: Language, options: {
+    en: T;
+} & { [language in Exclude<Language, "en">]?: T | null; }) => T;
+export {};

package/built/exerciseLocaleUtils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localeSelect = exports.localisedExerciseInstructions = exports.localisedExerciseTitle = exports.isSupportedInstructionsLanguage = exports.supportedInstructionsLanguages = void 0;
+const _1 = require(".");
+/** Keeping exercise instruction/title localization utils here instead of translations
+ * so I don't need to import exercise types from here in translations (translations was
+ * created so that hevy-web can import utils from shared without importing something from
+ * that isn't allowed in Edge Runtime)
+ */
+exports.supportedInstructionsLanguages = [
+    'en',
+    'it',
+    'de',
+    'es',
+    'fr',
+    'pt',
+];
+const isSupportedInstructionsLanguage = (lang) => {
+    return (0, _1.isInArray)(lang, exports.supportedInstructionsLanguages);
+};
+exports.isSupportedInstructionsLanguage = isSupportedInstructionsLanguage;
+const localisedExerciseTitle = (locale, template) => {
+    var _a;
+    if (template.is_custom) {
+        return template.title;
+    }
+    return ((_a = (0, exports.localeSelect)(locale, {
+        en: template.title,
+        es: template.es_title,
+        de: template.de_title,
+        fr: template.fr_title,
+        it: template.it_title,
+        pt: template.pt_title,
+        tr: template.tr_title,
+        zh_CN: template.zh_cn_title,
+        zh_TW: template.zh_tw_title,
+        ru: template.ru_title,
+        ja: template.ja_title,
+        ko: template.ko_title,
+    })) !== null && _a !== void 0 ? _a : template.title);
+};
+exports.localisedExerciseTitle = localisedExerciseTitle;
+const localisedExerciseInstructions = (locale, exerciseTemplate) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (exerciseTemplate.is_custom) {
+        return '';
+    }
+    return (0, exports.localeSelect)(locale, {
+        en: (_b = (_a = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _a === void 0 ? void 0 : _a.en) !== null && _b !== void 0 ? _b : '',
+        pt: (_c = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _c === void 0 ? void 0 : _c.pt,
+        de: (_d = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _d === void 0 ? void 0 : _d.de,
+        es: (_e = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _e === void 0 ? void 0 : _e.es,
+        it: (_f = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _f === void 0 ? void 0 : _f.it,
+        fr: (_g = exerciseTemplate === null || exerciseTemplate === void 0 ? void 0 : exerciseTemplate.localised_instructions) === null || _g === void 0 ? void 0 : _g.fr,
+    });
+};
+exports.localisedExerciseInstructions = localisedExerciseInstructions;
+const localeSelect = (locale, options) => {
+    var _a;
+    return (_a = options[locale]) !== null && _a !== void 0 ? _a : options.en;
+};
+exports.localeSelect = localeSelect;

package/built/filterExercises.d.ts

@@ -1,7 +1,19 @@
-import { EquipmentFilter, ExerciseTemplate, Language, MuscleGroupFilter } from './index';
-export interface SearchableExerciseTemplate extends ExerciseTemplate {
+import { EquipmentFilter, LibraryExercise, MuscleGroupFilter, CustomExercise } from './index';
+import { Language } from './translations';
+export interface SearchableLibraryExercise extends LibraryExercise {
     localized_muscle_group_name: string;
 }
+export interface SearchableCustomExercise extends CustomExercise {
+    localized_muscle_group_name: string;
+}
+export type SearchableExerciseTemplate = SearchableLibraryExercise | SearchableCustomExercise;
+export interface SearchableLibraryExerciseWithStringScore<T = number> extends SearchableLibraryExercise {
+    searchStringScore?: T;
+}
+export interface SearchableCustomExerciseWithStringScore<T = number> extends SearchableCustomExercise {
+    searchStringScore?: T;
+}
+export type SearchableExerciseTemplateWithStringScore<T = number> = SearchableLibraryExerciseWithStringScore<T> | SearchableCustomExerciseWithStringScore<T>;
 interface FilterExercisesProps {
     exercises: SearchableExerciseTemplate[];
     muscleGroupFilter: MuscleGroupFilter;
@@ -9,7 +21,11 @@ interface FilterExercisesProps {
     searchText: string;
     language: Language;
 }
-export declare const filterExercises: ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }: FilterExercisesProps) => ExerciseTemplate[];
+export declare const getExerciseMatches: ({ exercises, muscleGroupFilter, equipmentType, searchText, language, }: FilterExercisesProps) => ExerciseSearchMatch<SearchableExerciseTemplate>[];
+export type ExerciseSearchMatch<T> = {
+    exercise: T;
+    matchType: 'title' | 'muscle_group' | 'other' | 'custom';
+};
 /**
  * Exercise templates that are shown at the top of the Exercise Library to
  * users who don't have any workouts logged.