hevy-shared 1.0.962 → 1.0.963

package/built/setIndicatorUtils.d.ts

@@ -1,5 +1,5 @@
 interface SetIndicatored {
-    indicator: 'warmup' | 'dropset' | 'failure' | 'normal' | any;
+    indicator: 'warmup' | 'dropset' | 'failure' | 'normal' | number;
 }
 interface Indexed {
     index: number;
@@ -30,7 +30,7 @@ interface Indexed {
  * ]
  * ```
  */
-export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) => (SetIndicatored & Indexed & T)[];
+export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) => Array<SetIndicatored & Indexed & T>;
 /**
  * This function is almost the exact same as `indexSetObjectsForUI`
  * but this function will change failure sets to normal. Because when
@@ -63,7 +63,8 @@ export declare const indexSetObjectsForUI: <T>(indexedSet: SetIndicatored[]) =>
  * ]
  * ```
  */
-export declare const indexSetObjectsForType: <T>(indexedSet: SetIndicatored[]) => (SetIndicatored & Indexed & T)[];
+export declare const indexSetObjectsForType: <T>(indexedSet: SetIndicatored[]) => Array<SetIndicatored & Indexed & T>;
 export type UserFacingSetIndicator = 'dropset' | 'warmup' | 'failure' | number;
 export declare const setObjectToUIFacingSetIndicator: (set: SetIndicatored & Indexed) => UserFacingSetIndicator;
+export declare const compareUserFacingSetIndicator: (indicatorA: UserFacingSetIndicator, indicatorB: UserFacingSetIndicator) => boolean;
 export {};

package/built/setIndicatorUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setObjectToUIFacingSetIndicator = exports.indexSetObjectsForType = exports.indexSetObjectsForUI = void 0;
+exports.compareUserFacingSetIndicator = exports.setObjectToUIFacingSetIndicator = exports.indexSetObjectsForType = exports.indexSetObjectsForUI = void 0;
 /**
  * Accepts any data structure like this:
  * [
@@ -110,3 +110,17 @@ const setObjectToUIFacingSetIndicator = (set) => {
     return set.index + 1;
 };
 exports.setObjectToUIFacingSetIndicator = setObjectToUIFacingSetIndicator;
+const compareUserFacingSetIndicator = (indicatorA, indicatorB) => {
+    const normalizedA = indicatorA === 'warmup'
+        ? 'warmup'
+        : indicatorA === 'dropset'
+            ? 'dropset'
+            : 'normal';
+    const normalizedB = indicatorB === 'warmup'
+        ? 'warmup'
+        : indicatorB === 'dropset'
+            ? 'dropset'
+            : 'normal';
+    return normalizedA === normalizedB;
+};
+exports.compareUserFacingSetIndicator = compareUserFacingSetIndicator;

package/built/tests/async.test.d.ts

@@ -0,0 +1 @@
+export {};

package/built/tests/async.test.js

@@ -0,0 +1,49 @@
+"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 });
+const async_1 = require("../async");
+const resolveAfterMs = (waitMs, value) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(value), waitMs);
+    });
+});
+const rejectAfterMs = (waitMs, value) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((_, reject) => {
+        setTimeout(() => reject(value), waitMs);
+    });
+});
+describe('async', () => {
+    describe('allToResolveOrReject', () => {
+        it('resolves when all the arguments have resolved or rejected', () => __awaiter(void 0, void 0, void 0, function* () {
+            const startMs = new Date().valueOf();
+            yield expect((0, async_1.allToResolveOrReject)([
+                resolveAfterMs(100, 'OK after 100 ms'),
+                resolveAfterMs(500, 'OK after 500 ms'),
+                rejectAfterMs(400, 'Error after 400 ms'),
+                resolveAfterMs(200, 'OK after 200 ms'),
+                rejectAfterMs(300, 'Error after 300 ms'),
+            ])).resolves.toEqual([
+                { isSuccess: true, value: 'OK after 100 ms' },
+                { isSuccess: true, value: 'OK after 500 ms' },
+                { isSuccess: false, error: 'Error after 400 ms' },
+                { isSuccess: true, value: 'OK after 200 ms' },
+                { isSuccess: false, error: 'Error after 300 ms' },
+            ]);
+            const endMs = new Date().valueOf();
+            // should be 500 ms + (0~10 ms), i.e. the time it takes for the last
+            // promise to resolve/reject
+            //
+            // give 50 ms of leeway in case there's a system hiccup
+            //
+            expect(endMs - startMs).toBeLessThan(550);
+        }), 1000);
+    });
+});

package/built/tests/hevyTrainer.test.d.ts

@@ -0,0 +1 @@
+export {};