@thumbmarkjs/thumbmarkjs 1.9.1 → 1.10.0

package/src/functions/filterComponents.test.ts

@@ -1,273 +0,0 @@
-import { getExcludeList, filterThumbmarkData } from './filterComponents';
-import { defaultOptions } from '../options';
-import { componentInterface } from '../factory';
-
-// Mock getBrowser so we can control browser detection in tests
-jest.mock('../components/system/browser', () => ({
-    getBrowser: jest.fn(() => ({ name: 'unknown', version: 'unknown' })),
-}));
-
-import { getBrowser } from '../components/system/browser';
-const mockGetBrowser = getBrowser as jest.Mock;
-
-const testData: componentInterface = {
-    one: '1',
-    two: 2,
-    three: { a: true, b: false },
-    speech: { hash: 'abc' },
-    canvas: { hash: 'def' },
-    audio: { sampleHash: 'ghi', other: 'jkl' },
-};
-
-// ── getExcludeList ──────────────────────────────────────────────
-
-describe('getExcludeList', () => {
-    beforeEach(() => {
-        mockGetBrowser.mockReturnValue({ name: 'unknown', version: 'unknown' });
-    });
-
-    test('returns empty when no options and unknown browser', () => {
-        expect(getExcludeList()).toEqual([]);
-    });
-
-    test('returns user exclude list as-is', () => {
-        const result = getExcludeList({ ...defaultOptions, exclude: ['one', 'two'] });
-        expect(result).toContain('one');
-        expect(result).toContain('two');
-    });
-
-    test("'always' rules apply even with empty stabilize", () => {
-        mockGetBrowser.mockReturnValue({ name: 'Firefox', version: '130.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: [] });
-        expect(result).toContain('speech');
-    });
-
-    test("'always' rules don't apply when browser doesn't match", () => {
-        mockGetBrowser.mockReturnValue({ name: 'Chrome', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: [] });
-        expect(result).not.toContain('speech');
-    });
-
-    test('stabilization rules expand for matching browser', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Firefox', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private'] });
-        expect(result).toContain('canvas');
-        expect(result).toContain('fonts');
-        expect(result).toContain('tls.extensions');
-    });
-
-    test('stabilization rules do not apply for non-matching browser', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Chrome', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private'] });
-        expect(result).not.toContain('canvas');
-        expect(result).not.toContain('fonts');
-        // Chrome does get some rules though
-        expect(result).toContain('header.acceptLanguage');
-        expect(result).toContain('tls.extensions');
-    });
-
-    test('version matching with >= syntax', () => {
-        // safari>=17 should match Safari 18
-        mockGetBrowser.mockReturnValue({ name: 'Safari', version: '18.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private'] });
-        expect(result).toContain('canvas');
-
-        // safari>=17 should match Safari 17
-        mockGetBrowser.mockReturnValue({ name: 'Safari', version: '17.0' });
-        const result17 = getExcludeList({ ...defaultOptions, stabilize: ['private'] });
-        expect(result17).toContain('canvas');
-
-        // safari>=17 should NOT match Safari 16
-        mockGetBrowser.mockReturnValue({ name: 'Safari', version: '16.5' });
-        const result16 = getExcludeList({ ...defaultOptions, stabilize: ['private'] });
-        expect(result16).not.toContain('canvas');
-    });
-
-    test('browser-independent rules always apply', () => {
-        // 'iframe' has { exclude: ['permissions'] } with no browsers key
-        mockGetBrowser.mockReturnValue({ name: 'Chrome', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['iframe'] });
-        expect(result).toContain('permissions');
-    });
-
-    test('vpn stabilization excludes ip for any browser', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Chrome', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['vpn'] });
-        expect(result).toContain('ip');
-    });
-
-    test('multiple stabilization options combine', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Firefox', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private', 'vpn'] });
-        expect(result).toContain('canvas');  // from private+firefox
-        expect(result).toContain('ip');      // from vpn
-        expect(result).toContain('speech');  // from always+firefox
-    });
-
-    test('user exclude list is combined with stabilization rules', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Firefox', version: '120.0' });
-        const result = getExcludeList({ ...defaultOptions, exclude: ['custom'], stabilize: ['private'] });
-        expect(result).toContain('custom');  // user's
-        expect(result).toContain('canvas');  // from rules
-    });
-
-    test('unknown stabilization option is silently skipped', () => {
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['nonexistent' as any] });
-        // Should not throw, just return whatever 'always' contributes (nothing for unknown browser)
-        expect(Array.isArray(result)).toBe(true);
-    });
-
-    test('browser fallback from component data (server-side)', () => {
-        // getBrowser returns unknown (simulating server-side)
-        mockGetBrowser.mockReturnValue({ name: 'unknown', version: 'unknown' });
-
-        const obj: componentInterface = {
-            system: {
-                browser: {
-                    name: 'Brave',
-                    version: '130.0',
-                },
-            },
-        };
-
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private'] }, obj);
-        // Brave-specific rules should apply via fallback
-        expect(result).toContain('canvas');
-        expect(result).toContain('plugins');
-        expect(result).toContain('speech');  // from 'always'
-    });
-
-    test('browser fallback is skipped when getBrowser succeeds', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Chrome', version: '120.0' });
-
-        const obj: componentInterface = {
-            system: {
-                browser: {
-                    name: 'Firefox',
-                    version: '120.0',
-                },
-            },
-        };
-
-        const result = getExcludeList({ ...defaultOptions, stabilize: ['private'] }, obj);
-        // Should use Chrome rules (from getBrowser), not Firefox (from obj)
-        expect(result).toContain('header.acceptLanguage');  // Chrome rule
-        expect(result).not.toContain('fonts');               // Firefox-only rule
-    });
-
-    test('browser fallback handles missing system gracefully', () => {
-        mockGetBrowser.mockReturnValue({ name: 'unknown', version: 'unknown' });
-        const obj: componentInterface = { one: '1' };
-        // Should not throw
-        expect(() => getExcludeList({ ...defaultOptions }, obj)).not.toThrow();
-    });
-
-    test('non-array string exclude does not throw and is ignored', () => {
-        const result = getExcludeList({ ...defaultOptions, exclude: 'one' as any, stabilize: [] });
-        expect(Array.isArray(result)).toBe(true);
-        expect(result).not.toContain('one');
-    });
-
-    test('non-array object exclude does not throw and is ignored', () => {
-        const result = getExcludeList({ ...defaultOptions, exclude: {} as any, stabilize: [] });
-        expect(Array.isArray(result)).toBe(true);
-    });
-});
-
-// ── filterThumbmarkData ─────────────────────────────────────────
-
-describe('filterThumbmarkData', () => {
-    beforeEach(() => {
-        mockGetBrowser.mockReturnValue({ name: 'unknown', version: 'unknown' });
-    });
-
-    test('returns full object with no options', () => {
-        const result = filterThumbmarkData(testData);
-        expect(result).toEqual(testData);
-    });
-
-    test('returns full object with empty exclude', () => {
-        const result = filterThumbmarkData(testData, { ...defaultOptions, exclude: [], stabilize: [] });
-        expect(result).toEqual(testData);
-    });
-
-    test('include overrides exclude for the same key', () => {
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            exclude: ['one'],
-            include: ['one'],
-            stabilize: [],
-        });
-        expect(result.one).toBe('1');
-    });
-
-    test('include overrides exclude at nested level', () => {
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            exclude: ['three'],
-            include: ['three.a'],
-            stabilize: [],
-        });
-        expect(result.three).toEqual({ a: true });
-        expect((result.three as componentInterface).b).toBeUndefined();
-    });
-
-    test('excluding a parent removes all children', () => {
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            exclude: ['three'],
-            stabilize: [],
-        });
-        expect(result.three).toBeUndefined();
-    });
-
-    test('stabilization rules integrate with filterThumbmarkData', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Brave', version: '130.0' });
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            stabilize: ['private'],
-        });
-        // Brave+private excludes canvas
-        expect(result.canvas).toBeUndefined();
-        // Brave+'always' excludes speech
-        expect(result.speech).toBeUndefined();
-        // Others remain
-        expect(result.one).toBe('1');
-    });
-
-    test('nested exclusion via stabilization rules', () => {
-        mockGetBrowser.mockReturnValue({ name: 'Brave', version: '130.0' });
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            stabilize: ['private'],
-        });
-        // audio.sampleHash excluded for Brave, but audio.other should remain
-        expect(result.audio).toBeDefined();
-        expect((result.audio as componentInterface).other).toBe('jkl');
-        expect((result.audio as componentInterface).sampleHash).toBeUndefined();
-    });
-
-    test('non-array string include does not throw and does not rescue excluded keys', () => {
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            exclude: ['one'],
-            include: 'one' as any,
-            stabilize: [],
-        });
-        // Bad include is treated as empty, so 'one' stays excluded
-        expect(result.one).toBeUndefined();
-        expect(result.two).toBe(2);
-    });
-
-    test('null include does not throw and behaves as empty include', () => {
-        const result = filterThumbmarkData(testData, {
-            ...defaultOptions,
-            exclude: ['two'],
-            include: null as any,
-            stabilize: [],
-        });
-        // null include treated as empty, so 'two' stays excluded
-        expect(result.two).toBeUndefined();
-        expect(result.one).toBe('1');
-    });
-});

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}`);
-    })
-})