@thumbmarkjs/thumbmarkjs 1.9.0 → 1.10.0

package/src/functions/functions.test.ts

@@ -1,142 +0,0 @@
-import { componentInterface } from '../factory'
-import { filterThumbmarkData } from './filterComponents'
-import { resolveClientComponents, getThumbmark } from '.';
-import { defaultOptions } from '../options';
-
-const test_components: componentInterface = {
-    'one': '1',
-    'two': 2,
-    'three': {'a': true, 'b': false}
-}
-
-describe('component filtering tests', () => {
-    test("excluding top level works", () => {
-        expect(filterThumbmarkData(test_components, 
-            { ...defaultOptions, ...{ exclude: ['one']} }
-        )).toMatchObject({
-            'two': 2, 'three': {'a': true, 'b': false}
-        })
-    });
-    test("including top level works", () => {
-        expect(filterThumbmarkData(test_components, { ...defaultOptions, ...{ include: ['one', 'two']} })).toMatchObject({
-            'one': '1', 'two': 2
-        })
-    });
-    test("excluding low-level works", () => {
-        expect(filterThumbmarkData(test_components,
-            { ...defaultOptions, ...{ exclude: ['two', 'three.a']} }
-        )).toMatchObject({
-            'one': '1',
-            'three': {'b': false}
-        })
-    });
-    test("including low-level works", () => {
-        expect(filterThumbmarkData(test_components,
-            { ...defaultOptions, ...{ include: ['one', 'three.b']} })).toMatchObject({
-            'one': '1',
-            'three': {'b': false}
-        })
-    });
-});
-
-describe('resolveClientComponents runtime stability', () => {
-    test('continues resolving when one component promise rejects', async () => {
-        const components = {
-            stable: async () => ({ value: 'ok' } as componentInterface),
-            unstable: async () => Promise.reject(new Error('component failed')),
-        };
-
-        const { resolvedComponents, elapsed, errors } = await resolveClientComponents(components, {
-            ...defaultOptions,
-            stabilize: [],
-        });
-
-        expect(resolvedComponents.stable).toEqual({ value: 'ok' });
-        expect(resolvedComponents.unstable).toEqual({ timeout: 'true' });
-        expect(elapsed.stable).toBeGreaterThanOrEqual(0);
-        expect(elapsed.unstable).toBeGreaterThanOrEqual(0);
-        expect(errors).toEqual([
-            { type: 'component_error', message: 'component failed', component: 'unstable' }
-        ]);
-    });
-
-    test('reports component timeout in errors', async () => {
-        const components = {
-            fast: async () => ({ value: 'ok' } as componentInterface),
-            slow: () => new Promise<componentInterface>(() => {}),
-        };
-
-        const { resolvedComponents, errors } = await resolveClientComponents(components, {
-            ...defaultOptions,
-            timeout: 10,
-            stabilize: [],
-        });
-
-        expect(resolvedComponents.fast).toEqual({ value: 'ok' });
-        expect(errors).toEqual([
-            { type: 'component_timeout', message: "Component 'slow' timed out", component: 'slow' }
-        ]);
-    });
-
-    test('returns empty errors when all components succeed', async () => {
-        const components = {
-            a: async () => ({ value: '1' } as componentInterface),
-            b: async () => ({ value: '2' } as componentInterface),
-        };
-
-        const { errors } = await resolveClientComponents(components, {
-            ...defaultOptions,
-            stabilize: [],
-        });
-
-        expect(errors).toEqual([]);
-    });
-});
-
-describe('getThumbmark error reporting', () => {
-    test('returns api_unauthorized error for 403 response', async () => {
-        const originalFetch = global.fetch;
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: false,
-            status: 403,
-        });
-
-        const result = await getThumbmark({
-            ...defaultOptions,
-            api_key: 'fake-invalid-key',
-            cache_api_call: false,
-        });
-
-        expect(result.error).toEqual([
-            { type: 'api_unauthorized', message: 'Invalid API key or quota exceeded' }
-        ]);
-        expect(result.thumbmark).toBe('');
-
-        global.fetch = originalFetch;
-    });
-
-    test('returns api_error for 5xx response', async () => {
-        const originalFetch = global.fetch;
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: false,
-            status: 500,
-        });
-
-        const result = await getThumbmark({
-            ...defaultOptions,
-            api_key: 'some-key',
-            cache_api_call: false,
-        });
-
-        expect(result.error).toEqual(
-            expect.arrayContaining([
-                expect.objectContaining({ type: 'api_error', message: 'HTTP error! status: 500' })
-            ])
-        );
-        // Should still return a fingerprint (graceful degradation)
-        expect(result.thumbmark).toBeDefined();
-        expect(result.thumbmark.length).toBeGreaterThan(0);
-
-        global.fetch = originalFetch;
-    });
-});

package/src/functions/metadata.test.ts

@@ -1,211 +0,0 @@
-import { getApiPromise, apiResponse } from './api';
-import { OptionsAfterDefaults } from '../options';
-import { componentInterface } from '../factory';
-
-// Mock fetch globally
-global.fetch = jest.fn();
-
-describe('Metadata Support', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        (global.fetch as jest.Mock).mockResolvedValue({
-            ok: true,
-            json: async () => ({
-                thumbmark: 'test-thumbmark',
-                visitorId: 'test-visitor',
-                requestId: 'test-request',
-                metadata: 'test-metadata',
-            }),
-        });
-        // Spy on console.error
-        jest.spyOn(console, 'error').mockImplementation(() => { });
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    it('should include static metadata string in request body', async () => {
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: 'event-123',
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        expect(requestBody.metadata).toBe('event-123');
-    });
-
-    it('should evaluate metadata function and include result in request body', async () => {
-        let counter = 0;
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: () => `call-${++counter}`,
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        expect(requestBody.metadata).toBe('call-1');
-    });
-
-    it('should call metadata function each time get is invoked', async () => {
-        let counter = 0;
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: () => `call-${++counter}`,
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        // First call
-        await getApiPromise(options as OptionsAfterDefaults, components);
-        const firstCallArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const firstRequestBody = JSON.parse(firstCallArgs[1].body);
-        expect(firstRequestBody.metadata).toBe('call-1');
-
-        // Second call
-        await getApiPromise(options as OptionsAfterDefaults, components);
-        const secondCallArgs = (global.fetch as jest.Mock).mock.calls[1];
-        const secondRequestBody = JSON.parse(secondCallArgs[1].body);
-        expect(secondRequestBody.metadata).toBe('call-2');
-    });
-
-    it('should omit metadata from request body when not provided', async () => {
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        expect(requestBody.metadata).toBeUndefined();
-    });
-
-    it('should echo metadata back in API response', async () => {
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: '{"eventId": "12345"}',
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        const response = await getApiPromise(options as OptionsAfterDefaults, components);
-
-        expect(response).toBeDefined();
-        expect(response?.metadata).toBe('test-metadata');
-    });
-
-    it('should handle various string metadata types', async () => {
-        const testCases = [
-            'simple-string',
-            '{"json": "object"}',
-            'encrypted:abc123def456',
-            'multi\nline\nstring',
-            '🎉 unicode 中文',
-        ];
-
-        for (const metadata of testCases) {
-            const options: Partial<OptionsAfterDefaults> = {
-                api_key: 'test-key',
-                metadata,
-                cache_api_call: false,
-            };
-            const components: componentInterface = { system: { browser: 'chrome' } };
-
-            await getApiPromise(options as OptionsAfterDefaults, components);
-
-            const callArgs = (global.fetch as jest.Mock).mock.calls[
-                (global.fetch as jest.Mock).mock.calls.length - 1
-            ];
-            const requestBody = JSON.parse(callArgs[1].body);
-            expect(requestBody.metadata).toBe(metadata);
-        }
-    });
-
-    it('should handle empty string metadata', async () => {
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: '',
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        // Empty string is falsy, so it won't be included
-        expect(requestBody.metadata).toBeUndefined();
-    });
-
-    it('should handle metadata function returning empty string', async () => {
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: () => '',
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        // Empty string is falsy, so it won't be included
-        expect(requestBody.metadata).toBeUndefined();
-    });
-
-    it('should log error and omit metadata if length exceeds 1000 characters', async () => {
-        const longMetadata = 'a'.repeat(1001);
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: longMetadata,
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        // Check that fetch was called
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-
-        // precise console error check
-        expect(console.error).toHaveBeenCalledWith('ThumbmarkJS: Metadata exceeds 1000 characters. Skipping metadata.');
-
-        // Check that metadata was omitted
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        expect(requestBody.metadata).toBeUndefined();
-    });
-
-    it('should accept metadata exactly 1000 characters check', async () => {
-        const validMetadata = 'a'.repeat(1000);
-        const options: Partial<OptionsAfterDefaults> = {
-            api_key: 'test-key',
-            metadata: validMetadata,
-            cache_api_call: false,
-        };
-        const components: componentInterface = { system: { browser: 'chrome' } };
-
-        await getApiPromise(options as OptionsAfterDefaults, components);
-
-        expect(console.error).not.toHaveBeenCalledWith('ThumbmarkJS: Metadata exceeds 1000 characters. Skipping metadata.');
-
-        const callArgs = (global.fetch as jest.Mock).mock.calls[0];
-        const requestBody = JSON.parse(callArgs[1].body);
-        expect(requestBody.metadata).toBe(validMetadata);
-    });
-});

package/src/options.test.ts

@@ -1,10 +0,0 @@
-import { DEFAULT_STORAGE_PREFIX, defaultOptions } from "./options";
-
-describe('property_name_factory', () => {
-    test('it should default to the default value', () => {
-        const name = 'mykey';
-        expect(
-            defaultOptions.property_name_factory(name)
-        ).toEqual(`${DEFAULT_STORAGE_PREFIX}_${name}`);
-    })
-})

package/src/thumbmark.custom-components.test.ts

@@ -1,87 +0,0 @@
-import { Thumbmark } from './thumbmark';
-import { customComponents } from './factory';
-import { getThumbmark, includeComponent as includeGlobalComponent } from './index';
-
-describe('Thumbmark custom components', () => {
-    beforeEach(() => {
-        for (const key of Object.keys(customComponents)) {
-            delete customComponents[key];
-        }
-    });
-
-    test('custom components stay scoped to the instance that registered them', async () => {
-        const tm1 = new Thumbmark({ logging: false });
-        const tm2 = new Thumbmark({ logging: false });
-
-        tm1.includeComponent('instanceOnly', async () => ({
-            value: 'tm1'
-        }));
-
-        const tm1Result = await tm1.get({ include: ['instanceOnly'] });
-        const tm2Result = await tm2.get({ include: ['instanceOnly'] });
-
-        expect(tm1Result.components.instanceOnly).toEqual({ value: 'tm1' });
-        expect(tm2Result.components.instanceOnly).toBeUndefined();
-    });
-
-    test('deprecated global includeComponent still registers components for getThumbmark', async () => {
-        includeGlobalComponent('legacyGlobal', async () => ({
-            value: 'global'
-        }));
-
-        const result = await getThumbmark({
-            logging: false,
-            include: ['legacyGlobal']
-        });
-
-        expect(result.components.legacyGlobal).toEqual({ value: 'global' });
-    });
-
-    test('getThumbmark accepts an optional custom component registry', async () => {
-        const result = await getThumbmark({
-            logging: false,
-            include: ['directCustom']
-        }, {
-            directCustom: async () => ({
-                value: 'direct'
-            })
-        });
-
-        expect(result.components.directCustom).toEqual({ value: 'direct' });
-    });
-
-    test('deprecated global includeComponent still registers components for Thumbmark.get()', async () => {
-        includeGlobalComponent('legacyGlobal', async () => ({
-            value: 'global'
-        }));
-
-        const tm = new Thumbmark({ logging: false });
-        const result = await tm.get({
-            include: ['legacyGlobal']
-        });
-
-        expect(result.components.legacyGlobal).toEqual({ value: 'global' });
-    });
-
-    test('instance custom components override deprecated global ones for the same key', async () => {
-        includeGlobalComponent('sharedKey', async () => ({
-            value: 'global'
-        }));
-
-        const tm = new Thumbmark({ logging: false });
-        tm.includeComponent('sharedKey', async () => ({
-            value: 'instance'
-        }));
-
-        const globalResult = await getThumbmark({
-            logging: false,
-            include: ['sharedKey']
-        });
-        const instanceResult = await tm.get({
-            include: ['sharedKey']
-        });
-
-        expect(globalResult.components.sharedKey).toEqual({ value: 'global' });
-        expect(instanceResult.components.sharedKey).toEqual({ value: 'instance' });
-    });
-});

package/src/thumbmark.test.ts

@@ -1,59 +0,0 @@
-/**
- * Tests for Thumbmark class behavior in Node/Jest environment
- *
- * These tests verify that Thumbmark works gracefully when browser APIs
- * are not available (e.g., in Jest/jsdom or server-side environments).
- */
-
-import { Thumbmark } from './thumbmark';
-import { jest } from '@jest/globals';
-
-// Polyfill for sessionStorage in Node environment
-if (typeof sessionStorage === 'undefined') {
-    (global as any).sessionStorage = {
-        getItem: jest.fn(),
-        setItem: jest.fn(),
-        removeItem: jest.fn(),
-        clear: jest.fn(),
-        length: 0,
-        key: jest.fn(),
-    };
-}
-
-
-describe('Thumbmark in Node/Jest environment', () => {
-    test('Thumbmark.get() should not throw in non-browser environment', async () => {
-        const tm = new Thumbmark();
-
-        // This should not throw, even if browser APIs are unavailable
-        const result = await tm.get();
-
-        // Should return a valid result with structure
-        expect(result).toBeDefined();
-        expect(result.thumbmark).toBeDefined();
-        expect(typeof result.thumbmark).toBe('string');
-    });
-
-    test('Thumbmark.get() returns valid structure even with missing browser APIs', async () => {
-        const tm = new Thumbmark();
-
-        const result = await tm.get();
-
-        // Verify the response structure
-        expect(result).toHaveProperty('thumbmark');
-        expect(result).toHaveProperty('components');
-        expect(result).toHaveProperty('version');
-        expect(result).toHaveProperty('info');
-
-        // Components should be an object (possibly with fewer values than in real browser)
-        expect(typeof result.components).toBe('object');
-    });
-
-    test('Thumbmark.getVersion() works in any environment', () => {
-        const tm = new Thumbmark();
-        const version = tm.getVersion();
-
-        expect(version).toBeDefined();
-        expect(typeof version).toBe('string');
-    });
-});

package/src/utils/cache.test.ts

@@ -1,95 +0,0 @@
-import { Cache, getCache, setCache, getApiResponseExpiry, CACHE_KEY } from "./cache";
-import { DEFAULT_STORAGE_PREFIX, defaultOptions, MAXIMUM_CACHE_LIFETIME } from "../options";
-
-const _options = {
-    property_name_factory: (name: string) => {
-        return `${name}-mypostfix`;
-    },
-    cache_lifetime_in_ms: 0,
-};
-
-const values: Cache = {
-    apiResponseExpiry: 100,
-    apiResponse: {
-        version: '1.2.3',
-    },
-};
-
-const cacheProperty = defaultOptions.property_name_factory(CACHE_KEY);
-const customCacheProperty = _options.property_name_factory(CACHE_KEY);
-
-describe('getCache', () => {
-    beforeEach(() => {
-        localStorage.clear();
-    });
-
-    test('it should return all values from cache', () => {
-        localStorage.setItem(cacheProperty, JSON.stringify(values));
-        const fromStorage = getCache(defaultOptions);
-
-        expect(fromStorage).toEqual(values);
-    });
-
-    test('it should return an empty object in case of nothing cached', () => {
-        expect(getCache(defaultOptions)).toEqual({});
-    });
-
-    test('it should return an empty object in case non-json content', () => {
-        localStorage.setItem(cacheProperty, 'abc123');
-        expect(getCache(defaultOptions)).toEqual({});
-    });
-
-    test('it should return from the correct property', () => {
-        localStorage.setItem(cacheProperty, JSON.stringify(values));
-
-        expect(getCache(_options)).toEqual({});
-        expect(getCache(defaultOptions)).toEqual(values);
-    });
-})
-
-describe('setCache', () => {
-    beforeEach(() => {
-        localStorage.clear();
-    });
-
-    test('it should write given values', () => {
-        setCache(defaultOptions, values);
-        expect(JSON.parse(localStorage.getItem(cacheProperty)!))
-            .toEqual(values);
-    });
-
-    test('it should not touch values that are not provided', () => {
-        setCache(_options, values);
-        setCache(_options, {
-            apiResponseExpiry: 200
-        });
-        const fromStorage = JSON.parse(localStorage.getItem(customCacheProperty)!) as Cache;
-        expect(fromStorage.apiResponseExpiry).toEqual(200);
-        expect(fromStorage.apiResponse!.version).toEqual(values.apiResponse!.version);
-    })
-})
-
-describe('getApiResponseExpiry', () => {
-    const systemTime = 1000;
-    beforeAll(() => {
-        jest.useFakeTimers().setSystemTime(systemTime);
-        localStorage.clear();
-    });
-
-    test('it should return a value based on options', () => {
-        expect(getApiResponseExpiry({
-            cache_lifetime_in_ms: 100,
-        })).toBe(systemTime + 100);
-    });
-
-    test('it should not go over maximum cache lifetime', () => {
-        expect(getApiResponseExpiry({
-            cache_lifetime_in_ms: MAXIMUM_CACHE_LIFETIME + 200,
-        })).toBe(systemTime + MAXIMUM_CACHE_LIFETIME);
-    })
-
-    afterAll(() => {
-        jest.useRealTimers()
-    })
-})
-

package/src/utils/raceAll.test.ts

@@ -1,86 +0,0 @@
-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();
-    });
-});