@thumbmarkjs/thumbmarkjs 1.7.5 → 1.8.0

package/src/components/mediaDevices/index.test.ts

@@ -0,0 +1,120 @@
+import getMediaDevices from './index';
+
+describe('mediaDevices component tests', () => {
+  let originalMediaDevices: MediaDevices | undefined;
+
+  beforeAll(() => {
+    originalMediaDevices = navigator.mediaDevices;
+  });
+
+  afterAll(() => {
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: originalMediaDevices,
+      configurable: true,
+    });
+  });
+
+  function mockEnumerateDevices(devices: Array<{ kind: string }>) {
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: {
+        enumerateDevices: jest.fn().mockResolvedValue(devices),
+      },
+      configurable: true,
+    });
+  }
+
+  test('returns valid structure when API is available', async () => {
+    mockEnumerateDevices([
+      { kind: 'audioinput' },
+      { kind: 'audiooutput' },
+      { kind: 'videoinput' },
+    ]);
+
+    const result = await getMediaDevices();
+
+    expect(result).toEqual({
+      audioinput: 1,
+      audiooutput: 1,
+      videoinput: 1,
+    });
+  });
+
+  test('returns null when mediaDevices API is unavailable', async () => {
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: undefined,
+      configurable: true,
+    });
+
+    const result = await getMediaDevices();
+    expect(result).toBeNull();
+  });
+
+  test('returns null when enumerateDevices throws', async () => {
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: {
+        enumerateDevices: jest.fn().mockRejectedValue(new Error('NotAllowedError')),
+      },
+      configurable: true,
+    });
+
+    const result = await getMediaDevices();
+    expect(result).toBeNull();
+  });
+
+  test('handles empty device list', async () => {
+    mockEnumerateDevices([]);
+
+    const result = await getMediaDevices();
+
+    expect(result).toEqual({
+      audioinput: 0,
+      audiooutput: 0,
+      videoinput: 0,
+    });
+  });
+
+  test('counts multiple devices of same kind', async () => {
+    mockEnumerateDevices([
+      { kind: 'videoinput' },
+      { kind: 'videoinput' },
+      { kind: 'audioinput' },
+    ]);
+
+    const result = await getMediaDevices();
+
+    expect(result).toEqual({
+      audioinput: 1,
+      audiooutput: 0,
+      videoinput: 2,
+    });
+  });
+
+  test('ignores unknown device kind values', async () => {
+    mockEnumerateDevices([
+      { kind: 'audioinput' },
+      { kind: '' },
+      { kind: 'somethingelse' },
+      { kind: 'videoinput' },
+    ]);
+
+    const result = await getMediaDevices();
+
+    expect(result).toEqual({
+      audioinput: 1,
+      audiooutput: 0,
+      videoinput: 1,
+    });
+  });
+
+  test('returns null when enumerateDevices resolves with null', async () => {
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: {
+        enumerateDevices: jest.fn().mockResolvedValue(null),
+      },
+      configurable: true,
+    });
+
+    const result = await getMediaDevices();
+    expect(result).toBeNull();
+  });
+});

package/src/components/mediaDevices/index.ts

@@ -0,0 +1,26 @@
+import { componentInterface } from '../../factory';
+
+export default async function getMediaDevices(): Promise<componentInterface | null> {
+  if (typeof navigator === 'undefined' ||
+    !navigator.mediaDevices ||
+    typeof navigator.mediaDevices.enumerateDevices !== 'function') {
+    return null;
+  }
+
+  try {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+
+    const counts: Record<string, number> = {};
+    for (const device of devices) {
+      counts[device.kind] = (counts[device.kind] || 0) + 1;
+    }
+
+    return {
+      audioinput: counts['audioinput'] || 0,
+      audiooutput: counts['audiooutput'] || 0,
+      videoinput: counts['videoinput'] || 0,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/factory.ts

@@ -21,6 +21,8 @@ import getSystem from "./components/system";
 import getWebGL from "./components/webgl";
 
 // Import experimental component functions
+import getIntl from "./components/intl";
+import getMediaDevices from "./components/mediaDevices";
 import getWebRTC from "./components/webrtc";
 import getMathML from "./components/mathml";
 import getSpeech from "./components/speech";
@@ -48,7 +50,9 @@ export const tm_component_promises = {
  * @description key->function map of experimental components. Only resolved during logging.
  */
 export const tm_experimental_component_promises = {
+    'intl': getIntl,
     'mathml': getMathML,
+    'mediadevices': getMediaDevices,
 };
 
 // the component interface is the form of the JSON object the function's promise must return

package/src/functions/api.test.ts

@@ -275,6 +275,57 @@ describe('getApiPromise timeout behavior', () => {
         expect(result?.visitorId).toBe(storedVisitorId);
     });
 
+    test('retries on network error and succeeds on second attempt', async () => {
+        jest.useRealTimers();
+        const noCacheOptions = { ...testOptions, cache_api_call: false, timeout: 5000 };
+
+        mockFetch
+            .mockRejectedValueOnce(new TypeError('Failed to fetch'))
+            .mockResolvedValueOnce({
+                ok: true, status: 200,
+                json: async () => ({ version: '1.0', thumbmark: 'retry-ok' }),
+            });
+
+        const result = await getApiPromise(noCacheOptions, testComponents);
+
+        expect(mockFetch).toHaveBeenCalledTimes(2);
+        expect(result?.thumbmark).toBe('retry-ok');
+        jest.useFakeTimers();
+    });
+
+    test('does not retry on 500 server error', async () => {
+        jest.useRealTimers();
+        const noCacheOptions = { ...testOptions, cache_api_call: false, timeout: 5000 };
+
+        mockFetch.mockResolvedValueOnce({ ok: false, status: 500 });
+
+        await expect(getApiPromise(noCacheOptions, testComponents)).rejects.toThrow('HTTP error! status: 500');
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        jest.useFakeTimers();
+    });
+
+    test('does not retry on 403 auth error', async () => {
+        jest.useRealTimers();
+        const noCacheOptions = { ...testOptions, cache_api_call: false, timeout: 5000 };
+
+        mockFetch.mockResolvedValueOnce({ ok: false, status: 403 });
+
+        await expect(getApiPromise(noCacheOptions, testComponents)).rejects.toThrow('HTTP error! status: 403');
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        jest.useFakeTimers();
+    });
+
+    test('network errors exhaust retries then throw', async () => {
+        jest.useRealTimers();
+        const noCacheOptions = { ...testOptions, cache_api_call: false, timeout: 5000 };
+
+        mockFetch.mockRejectedValue(new TypeError('Failed to fetch'));
+
+        await expect(getApiPromise(noCacheOptions, testComponents)).rejects.toThrow('Failed to fetch');
+        expect(mockFetch).toHaveBeenCalledTimes(3);
+        jest.useFakeTimers();
+    });
+
     test('returns full cached response (not just visitorId) when cache exists on timeout', async () => {
         const noCacheOptions = {
             ...testOptions,

package/src/functions/api.ts

@@ -46,9 +46,62 @@ export interface apiResponse {
 
 // ===================== API Call Logic =====================
 
+export class ApiError extends Error {
+    constructor(public status: number) {
+        super(`HTTP error! status: ${status}`);
+    }
+}
+
 let currentApiPromise: Promise<apiResponse> | null = null;
 let apiPromiseResult: apiResponse | null = null;
 
+const MAX_RETRIES = 3;
+const RETRY_BACKOFF_MS = 200;
+
+/**
+ * Calls the API endpoint once. Returns the response data on success.
+ * Throws ApiError on HTTP errors, or a native error on network failures.
+ */
+async function callApi(
+    endpoint: string, body: any, options: OptionsAfterDefaults, visitorId: string | null,
+): Promise<apiResponse> {
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'x-api-key': options.api_key!,
+            'Authorization': 'custom-authorized',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (!response.ok) throw new ApiError(response.status);
+
+    const data = await response.json();
+    if (data.visitorId && data.visitorId !== visitorId) setVisitorId(data.visitorId, options);
+    apiPromiseResult = data;
+    setCachedApiResponse(options, data);
+    return data;
+}
+
+/**
+ * Calls callApi with retries on network errors.
+ * HTTP errors (ApiError) are not retried — only network failures.
+ */
+async function callApiWithRetry(
+    endpoint: string, body: any, options: OptionsAfterDefaults, visitorId: string | null,
+): Promise<apiResponse> {
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        if (attempt > 0) await new Promise(r => setTimeout(r, attempt * RETRY_BACKOFF_MS));
+        try {
+            return await callApi(endpoint, body, options, visitorId);
+        } catch (error) {
+            if (error instanceof ApiError || attempt === MAX_RETRIES - 1) throw error;
+        }
+    }
+    throw new Error('Unreachable');
+}
+
 /**
  * Calls the Thumbmark API with the given components, using caching and deduplication.
  * Returns a promise for the API response or null on error.
@@ -109,61 +162,19 @@ export const getApiPromise = (
         }
     }
 
-    const fetchPromise = fetch(endpoint, {
-        method: 'POST',
-        headers: {
-            'x-api-key': options.api_key!,
-            'Authorization': 'custom-authorized',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(requestBody),
-    })
-        .then(response => {
-            // Handle HTTP errors that aren't network errors
-            if (!response.ok) {
-                if (response.status === 403) {
-                    throw new Error('INVALID_API_KEY');
-                }
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            return response.json();
-        })
-        .then(data => {
-            // Handle visitor ID from server response
-            if (data.visitorId && data.visitorId !== visitorId) {
-                setVisitorId(data.visitorId, options);
-            }
-            apiPromiseResult = data;      // Cache the successful result
-            setCachedApiResponse(options, data); // Cache to localStorage according to options
-            currentApiPromise = null;     // Clear the in-flight promise
-            return data;
-        })
-        .catch(error => {
-            currentApiPromise = null;     // Clear the in-flight promise on error
-            throw error;                  // Propagate all errors to caller
-        });
-
-    // Timeout logic
     const timeoutMs = options.timeout || 5000;
-    const timeoutPromise = new Promise<apiResponse>((resolve) => {
+
+    const apiCall = callApiWithRetry(endpoint, requestBody, options, visitorId)
+        .finally(() => { currentApiPromise = null; });
+
+    const timeout = new Promise<apiResponse>((resolve) => {
         setTimeout(() => {
-            // On timeout, try to return expired cache as fallback
-            // Note: getCache() returns cache regardless of expiry
             const cache = getCache(options);
-            if (cache && cache.apiResponse) {
-                resolve(cache.apiResponse);
-            } else {
-                // Even without caching, return the visitor ID if available
-                // (visitorId was already retrieved at the start of this function)
-                resolve({
-                    info: { timed_out: true },
-                    ...(visitorId && { visitorId }),
-                });
-            }
+            resolve(cache?.apiResponse || { info: { timed_out: true }, ...(visitorId && { visitorId }) });
         }, timeoutMs);
     });
 
-    currentApiPromise = Promise.race([fetchPromise, timeoutPromise]);
+    currentApiPromise = Promise.race([apiCall, timeout]);
     return currentApiPromise;
 };
 

package/src/functions/index.ts

@@ -21,7 +21,7 @@ import { raceAllPerformance } from "../utils/raceAll";
 import { getVersion } from "../utils/version";
 import { filterThumbmarkData, getExcludeList } from './filterComponents'
 import { logThumbmarkData } from '../utils/log';
-import { getApiPromise, infoInterface } from "./api";
+import { getApiPromise, ApiError, infoInterface } from "./api";
 import { stableStringify } from "../utils/stableStringify";
 
 
@@ -29,7 +29,7 @@ import { stableStringify } from "../utils/stableStringify";
  * Final thumbmark response structure
  */
 export interface ThumbmarkError {
-  type: 'component_timeout' | 'component_error' | 'api_timeout' | 'api_error' | 'api_unauthorized' | 'fatal';
+  type: 'component_timeout' | 'component_error' | 'api_timeout' | 'api_error' | 'api_unauthorized' | 'network_error' | 'fatal';
   message: string;
   component?: string;
 }
@@ -111,7 +111,7 @@ export async function getThumbmark(
       try {
         apiResult = await apiPromise;
       } catch (error) {
-        if (error instanceof Error && error.message === 'INVALID_API_KEY') {
+        if (error instanceof ApiError && error.status === 403) {
           return {
             error: [{ type: 'api_unauthorized', message: 'Invalid API key or quota exceeded' }],
             components: {},
@@ -120,9 +120,8 @@ export async function getThumbmark(
             thumbmark: ''
           };
         }
-        // Non-auth API errors (5xx, network): log error and continue without API data
         allErrors.push({
-          type: 'api_error',
+          type: error instanceof ApiError ? 'api_error' : 'network_error',
           message: error instanceof Error ? error.message : String(error)
         });
       }