@thumbmarkjs/thumbmarkjs 1.9.1 → 1.10.0

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

package/src/utils/stableStringify.test.ts

@@ -1,335 +0,0 @@
-import { stableStringify } from './stableStringify';
-
-describe('stableStringify', () => {
-    describe('basic functionality', () => {
-        test('sorts object keys alphabetically', () => {
-            const obj = { z: 3, a: 1, m: 2 };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"a":1,"m":2,"z":3}');
-        });
-
-        test('produces valid JSON', () => {
-            const obj = { b: 2, a: 1, c: 3 };
-            const result = stableStringify(obj);
-            expect(() => JSON.parse(result)).not.toThrow();
-            expect(JSON.parse(result)).toEqual({ a: 1, b: 2, c: 3 });
-        });
-
-        test('produces consistent output for same input', () => {
-            const obj = { z: 3, a: 1, m: 2 };
-            const result1 = stableStringify(obj);
-            const result2 = stableStringify(obj);
-            expect(result1).toBe(result2);
-        });
-
-        test('produces same output regardless of key insertion order', () => {
-            const obj1 = { a: 1, b: 2, c: 3 };
-            const obj2 = { c: 3, a: 1, b: 2 };
-            const obj3 = { b: 2, c: 3, a: 1 };
-
-            const result1 = stableStringify(obj1);
-            const result2 = stableStringify(obj2);
-            const result3 = stableStringify(obj3);
-
-            expect(result1).toBe(result2);
-            expect(result2).toBe(result3);
-        });
-    });
-
-    describe('nested objects', () => {
-        test('sorts keys in nested objects', () => {
-            const obj = {
-                z: { y: 2, x: 1 },
-                a: { c: 4, b: 3 }
-            };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"a":{"b":3,"c":4},"z":{"x":1,"y":2}}');
-        });
-
-        test('handles deeply nested objects', () => {
-            const obj = {
-                level1: {
-                    z: 'last',
-                    a: {
-                        nested: {
-                            z: 3,
-                            a: 1,
-                            m: 2
-                        }
-                    }
-                }
-            };
-            const result = stableStringify(obj);
-            const parsed = JSON.parse(result);
-            expect(parsed).toEqual({
-                level1: {
-                    a: {
-                        nested: {
-                            a: 1,
-                            m: 2,
-                            z: 3
-                        }
-                    },
-                    z: 'last'
-                }
-            });
-        });
-    });
-
-    describe('arrays', () => {
-        test('preserves array order', () => {
-            const arr = [3, 1, 2];
-            const result = stableStringify(arr);
-            expect(result).toBe('[3,1,2]');
-        });
-
-        test('handles arrays with objects', () => {
-            const arr = [
-                { z: 2, a: 1 },
-                { b: 4, a: 3 }
-            ];
-            const result = stableStringify(arr);
-            expect(result).toBe('[{"a":1,"z":2},{"a":3,"b":4}]');
-        });
-
-        test('handles nested arrays', () => {
-            const arr = [[3, 2, 1], [6, 5, 4]];
-            const result = stableStringify(arr);
-            expect(result).toBe('[[3,2,1],[6,5,4]]');
-        });
-
-        test('handles mixed arrays', () => {
-            const arr = [1, 'string', { z: 2, a: 1 }, [3, 4], null, true];
-            const result = stableStringify(arr);
-            expect(result).toBe('[1,"string",{"a":1,"z":2},[3,4],null,true]');
-        });
-    });
-
-    describe('primitive types', () => {
-        test('handles strings', () => {
-            expect(stableStringify('hello')).toBe('"hello"');
-        });
-
-        test('handles numbers', () => {
-            expect(stableStringify(42)).toBe('42');
-            expect(stableStringify(0)).toBe('0');
-            expect(stableStringify(-42)).toBe('-42');
-            expect(stableStringify(3.14)).toBe('3.14');
-        });
-
-        test('handles booleans', () => {
-            expect(stableStringify(true)).toBe('true');
-            expect(stableStringify(false)).toBe('false');
-        });
-
-        test('handles null', () => {
-            expect(stableStringify(null)).toBe('null');
-        });
-
-        test('handles undefined', () => {
-            expect(stableStringify(undefined)).toBe('');
-        });
-
-        test('handles undefined in objects', () => {
-            const obj = { a: 1, b: undefined, c: 3 };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"a":1,"c":3}');
-        });
-
-        test('handles undefined in arrays', () => {
-            const arr = [1, undefined, 3];
-            const result = stableStringify(arr);
-            expect(result).toBe('[1,null,3]');
-        });
-    });
-
-    describe('special number values', () => {
-        test('handles Infinity as null', () => {
-            expect(stableStringify(Infinity)).toBe('null');
-        });
-
-        test('handles -Infinity as null', () => {
-            expect(stableStringify(-Infinity)).toBe('null');
-        });
-
-        test('handles NaN as null', () => {
-            expect(stableStringify(NaN)).toBe('null');
-        });
-
-        test('handles special numbers in objects', () => {
-            const obj = { a: Infinity, b: NaN, c: -Infinity };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"a":null,"b":null,"c":null}');
-        });
-    });
-
-    describe('circular references', () => {
-        test('throws TypeError on circular reference', () => {
-            const obj: any = { a: 1 };
-            obj.self = obj;
-
-            expect(() => stableStringify(obj)).toThrow(TypeError);
-            expect(() => stableStringify(obj)).toThrow('Converting circular structure to JSON');
-        });
-
-        test('throws on nested circular reference', () => {
-            const obj: any = { a: { b: {} } };
-            obj.a.b.circular = obj;
-
-            expect(() => stableStringify(obj)).toThrow(TypeError);
-        });
-
-        test('throws on array circular reference', () => {
-            const arr: any = [1, 2, 3];
-            arr.push(arr);
-
-            // Note: Array circular references cause stack overflow (RangeError)
-            // rather than being caught by the circular reference check
-            expect(() => stableStringify(arr)).toThrow(RangeError);
-        });
-    });
-
-    describe('toJSON method', () => {
-        test('calls toJSON method if present', () => {
-            const obj = {
-                value: 42,
-                toJSON() {
-                    return { transformed: this.value * 2 };
-                }
-            };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"transformed":84}');
-        });
-
-        test('handles Date objects via toJSON', () => {
-            const date = new Date('2023-01-01T00:00:00.000Z');
-            const result = stableStringify(date);
-            expect(result).toBe('"2023-01-01T00:00:00.000Z"');
-        });
-
-        test('handles nested objects with toJSON', () => {
-            const obj = {
-                z: 'last',
-                a: {
-                    toJSON() {
-                        return { custom: 'value' };
-                    }
-                }
-            };
-            const result = stableStringify(obj);
-            expect(result).toBe('{"a":{"custom":"value"},"z":"last"}');
-        });
-    });
-
-    describe('complex scenarios', () => {
-        test('handles empty object', () => {
-            expect(stableStringify({})).toBe('{}');
-        });
-
-        test('handles empty array', () => {
-            expect(stableStringify([])).toBe('[]');
-        });
-
-        test('handles complex nested structure', () => {
-            const complex = {
-                users: [
-                    { name: 'Alice', age: 30, active: true },
-                    { name: 'Bob', age: 25, active: false }
-                ],
-                metadata: {
-                    version: 1,
-                    timestamp: 1234567890,
-                    config: {
-                        enabled: true,
-                        options: ['a', 'b', 'c']
-                    }
-                },
-                count: 42
-            };
-
-            const result = stableStringify(complex);
-            const parsed = JSON.parse(result);
-
-            // Verify it's valid JSON
-            expect(parsed).toBeDefined();
-
-            // Verify structure is preserved
-            expect(parsed.users).toHaveLength(2);
-            expect(parsed.metadata.config.options).toEqual(['a', 'b', 'c']);
-            expect(parsed.count).toBe(42);
-        });
-
-        test('handles objects with special characters in keys', () => {
-            const obj = {
-                'key with spaces': 1,
-                'key-with-dashes': 2,
-                'key_with_underscores': 3,
-                'key.with.dots': 4
-            };
-            const result = stableStringify(obj);
-            const parsed = JSON.parse(result);
-            expect(parsed).toEqual(obj);
-        });
-
-        test('handles objects with numeric string keys', () => {
-            const obj = { '2': 'two', '1': 'one', '10': 'ten' };
-            const result = stableStringify(obj);
-            // Keys should be sorted as strings: "1", "10", "2"
-            expect(result).toBe('{"1":"one","10":"ten","2":"two"}');
-        });
-    });
-
-    describe('JSON validity', () => {
-        test('output is always valid JSON for valid inputs', () => {
-            const testCases = [
-                { a: 1, b: 2 },
-                [1, 2, 3],
-                'string',
-                42,
-                true,
-                null,
-                { nested: { deeply: { value: 'test' } } },
-                [{ a: 1 }, { b: 2 }],
-                { arr: [1, 2, { c: 3 }] }
-            ];
-
-            testCases.forEach(testCase => {
-                const result = stableStringify(testCase);
-                expect(() => JSON.parse(result)).not.toThrow();
-            });
-        });
-
-        test('parsed output equals original structure', () => {
-            const obj = {
-                z: 3,
-                a: 1,
-                nested: {
-                    y: 2,
-                    x: 1
-                },
-                arr: [3, 2, 1]
-            };
-
-            const result = stableStringify(obj);
-            const parsed = JSON.parse(result);
-
-            expect(parsed).toEqual(obj);
-        });
-    });
-
-    describe('stability comparison', () => {
-        test('produces same hash for equivalent objects', () => {
-            const obj1 = { b: 2, a: 1, c: { z: 26, y: 25 } };
-            const obj2 = { c: { y: 25, z: 26 }, a: 1, b: 2 };
-
-            expect(stableStringify(obj1)).toBe(stableStringify(obj2));
-        });
-
-        test('produces different output for different objects', () => {
-            const obj1 = { a: 1, b: 2 };
-            const obj2 = { a: 1, b: 3 };
-
-            expect(stableStringify(obj1)).not.toBe(stableStringify(obj2));
-        });
-    });
-});