@thumbmarkjs/thumbmarkjs 1.7.0 → 1.7.2

package/src/utils/log.ts

@@ -1,6 +1,7 @@
 import { componentInterface } from '../factory';
 import { optionsInterface, DEFAULT_API_ENDPOINT } from '../options';
 import { getVersion } from './version';
+import type { ThumbmarkError } from '../functions';
 
 // ===================== Logging (Internal) =====================
 
@@ -9,7 +10,7 @@ import { getVersion } from './version';
  * You can disable this by setting options.logging to false.
  * @internal
  */
-export async function logThumbmarkData(thisHash: string, thumbmarkData: componentInterface, options: optionsInterface, experimentalData: componentInterface = {}): Promise<void> {
+export async function logThumbmarkData(thisHash: string, thumbmarkData: componentInterface, options: optionsInterface, experimentalData: componentInterface = {}, errors: ThumbmarkError[] = []): Promise<void> {
     const apiEndpoint = DEFAULT_API_ENDPOINT;
     const url = `${apiEndpoint}/log`;
     const payload = {
@@ -19,6 +20,7 @@ export async function logThumbmarkData(thisHash: string, thumbmarkData: componen
         version: getVersion(),
         options,
         path: window?.location?.pathname,
+        ...(errors.length > 0 && { errors }),
     };
 
     sessionStorage.setItem("_tmjs_l", "1");

package/src/utils/raceAll.test.ts

@@ -0,0 +1,86 @@
+import { raceAllPerformance, raceAll } from './raceAll';
+
+describe('raceAll', () => {
+    test('returns resolved values when promises fulfill', async () => {
+        const results = await raceAll(
+            [Promise.resolve('ok')],
+            50,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(1);
+        expect(results[0]).toBe('ok');
+    });
+
+    test('returns timeout fallback when promise does not settle in time', async () => {
+        const neverResolves = new Promise<string>(() => { });
+        const results = await raceAll(
+            [neverResolves],
+            10,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(1);
+        expect(results[0]).toBe('timeout');
+    });
+
+    test('does not reject the whole batch when one promise rejects', async () => {
+        const rejects = Promise.reject(new Error('component failed'));
+        const resolves = Promise.resolve('ok');
+
+        const results = await raceAll(
+            [rejects, resolves],
+            50,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(2);
+        expect(results[0]).toBe('timeout');
+        expect(results[1]).toBe('ok');
+    });
+});
+
+describe('raceAllPerformance', () => {
+    test('returns resolved values when promises fulfill', async () => {
+        const results = await raceAllPerformance(
+            [Promise.resolve('ok')],
+            50,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(1);
+        expect(results[0].value).toBe('ok');
+        expect(typeof results[0].elapsed).toBe('number');
+        expect(results[0].error).toBeUndefined();
+    });
+
+    test('returns timeout fallback when promise does not settle in time', async () => {
+        const neverResolves = new Promise<string>(() => { });
+        const results = await raceAllPerformance(
+            [neverResolves],
+            10,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(1);
+        expect(results[0].value).toBe('timeout');
+        expect(results[0].error).toBe('timeout');
+    });
+
+    test('does not reject the whole batch when one promise rejects', async () => {
+        const rejects = Promise.reject(new Error('component failed'));
+        const resolves = Promise.resolve('ok');
+
+        const results = await raceAllPerformance(
+            [rejects, resolves],
+            50,
+            'timeout'
+        );
+
+        expect(results).toHaveLength(2);
+        expect(results[0].value).toBe('timeout');
+        expect(results[0].error).toBe('component failed');
+        expect(results[1].value).toBe('ok');
+        expect(results[1].error).toBeUndefined();
+    });
+});

package/src/utils/raceAll.ts

@@ -10,6 +10,7 @@ export function delay<T>(t: number, val: T): DelayedPromise<T> {
 export interface RaceResult<T> {
   value: T;
   elapsed?: number;
+  error?: string;
 }
 
 export function raceAllPerformance<T>(
@@ -24,10 +25,15 @@ export function raceAllPerformance<T>(
         p.then((value) => ({
           value,
           elapsed: performance.now() - startTime,
+        })).catch((err: unknown) => ({
+          value: timeoutVal,
+          elapsed: performance.now() - startTime,
+          error: err instanceof Error ? err.message : String(err),
         })),
         delay(timeoutTime, timeoutVal).then((value) => ({
           value,
           elapsed: performance.now() - startTime,
+          error: 'timeout' as string,
         })),
       ]);
     })
@@ -38,6 +44,6 @@ export function raceAllPerformance<T>(
 
 export function raceAll<T>(promises: Promise<T>[], timeoutTime: number, timeoutVal: T): Promise<(T | undefined)[]> {
   return Promise.all(promises.map((p) => {
-    return Promise.race([p, delay(timeoutTime, timeoutVal)]);
+    return Promise.race([p.catch(() => timeoutVal), delay(timeoutTime, timeoutVal)]);
   }));
-}
+}