@thumbmarkjs/thumbmarkjs 0.20.5 → 1.0.0-rc.0

package/src/components/canvas/{canvas.ts → index.ts}

@@ -2,6 +2,7 @@ import { componentInterface, includeComponent } from '../../factory';
 import { getCommonPixels } from '../../utils/commonPixels';
 import { hash } from '../../utils/hash';
 import { getBrowser } from '../system/browser';
+import { optionsInterface } from '../../fingerprint/options';
 
 const browser = getBrowser();
 const name = browser.name.toLowerCase();
@@ -19,7 +20,15 @@ const _RUNS = 3;
 const _WIDTH = 280;
 const _HEIGHT = 20;
 
-export default function generateCanvasFingerprint(): Promise<componentInterface> {
+export default async function getCanvas(options?: optionsInterface): Promise<componentInterface | null> {
+  const browser = getBrowser()
+  if (name !== 'firefox' && !(name === 'safari' && majorVer >= 17))
+    return generateCanvasFingerprint()
+  return null;
+}
+
+
+export function generateCanvasFingerprint(): Promise<componentInterface> {
   const canvas = document.createElement('canvas');
   const ctx = canvas.getContext('2d');
 
@@ -33,7 +42,7 @@ export default function generateCanvasFingerprint(): Promise<componentInterface>
     const commonImageData = getCommonPixels(imageDatas, _WIDTH, _HEIGHT);
 
     resolve({
-      commonImageDataHash: hash(commonImageData.data.toString()).toString(),
+      commonPixelsHash: hash(commonImageData.data.toString()).toString(),
     });
   });
 }
@@ -85,9 +94,4 @@ function generateCanvasImageData(): ImageData {
   const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
   // Return data URL of the canvas
   return imageData;
-}
-
-// In Safari from version 17 in private and normal modes canvas differs
-if (name !== 'firefox' && !(name === 'safari' && majorVer === 17)) {
-  includeComponent('canvas', generateCanvasFingerprint);
-}
+}

package/src/components/fonts/{fonts.ts → index.ts}

@@ -1,6 +1,7 @@
 import { componentInterface, includeComponent } from '../../factory'
 import { ephemeralIFrame } from '../../utils/ephemeralIFrame'
 import { getBrowser } from '../system/browser'
+import { optionsInterface } from '../../fingerprint/options'
 
 interface FontMetrics {[k: string]: number}
 
@@ -98,7 +99,14 @@ const availableFonts = [
 
   const baseFonts = ['monospace', 'sans-serif', 'serif'];
 
-export default function getFontMetrics(): Promise<componentInterface> {
+export default async function getFonts(options?: optionsInterface): Promise<componentInterface | null> {
+  const browser = getBrowser()
+  if (!['Firefox'].includes(browser.name))
+    return getFontMetrics()
+  return null;
+}
+
+export function getFontMetrics(): Promise<componentInterface> {
     
     return new Promise((resolve, reject) => {
         try {
@@ -139,7 +147,4 @@ function measureSingleFont(ctx: CanvasRenderingContext2D | null, font: string):
     const defaultFont = ctx.font; // Store default font
     ctx.font = `72px ${font}`; // Set a default font size
     return ctx.measureText(text).width;
-}
-
-if (getBrowser().name != 'Firefox')
-    includeComponent('fonts', getFontMetrics);
+}

package/src/components/hardware/{hardware.ts → index.ts}

@@ -1,8 +1,8 @@
 import { componentInterface, includeComponent } from '../../factory'
 
-function getHardwareInfo(): Promise<componentInterface> {
+export default function getHardware(): Promise<componentInterface> {
   return new Promise((resolve, reject) => {
-    const deviceMemory = (navigator.deviceMemory !== undefined) ? navigator.deviceMemory : 0
+    const deviceMemory = ((navigator as any).deviceMemory !== undefined) ? (navigator as any).deviceMemory : 0
     const memoryInfo = (window.performance && (window.performance as any).memory ) ? (window.performance as any).memory : 0
     resolve(
       {
@@ -64,6 +64,4 @@ function getArchitecture(): number {
   f[0] = f[0] - f[0];
 
   return u8[3];
-}
-
-includeComponent('hardware', getHardwareInfo);
+}

package/src/components/locales/{locales.ts → index.ts}

@@ -1,6 +1,6 @@
 import { componentInterface, includeComponent } from '../../factory'
 
-function getLocales(): Promise<componentInterface> {
+export default function getLocales(): Promise<componentInterface> {
   return new Promise((resolve) => {
     resolve(
       {
@@ -18,6 +18,4 @@ function getUserLanguage(): string {
 
   function getUserTimezone(): string {
     return Intl.DateTimeFormat().resolvedOptions().timeZone;
-  }
-
-  includeComponent('locales', getLocales);
+  }

package/src/components/math/index.ts

@@ -0,0 +1,28 @@
+import { componentInterface, includeComponent } from '../../factory'
+
+const integrate = (f: (x: number) => number, a: number, b: number, n: number): number => {
+    const h = (b - a) / n;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const x = a + (i + 0.5) * h;
+        sum += f(x);
+    }
+    return sum * h;
+};
+
+export default function getMath(): Promise<componentInterface> {
+  return new Promise((resolve) => {
+    resolve(
+        {
+            'acos': Math.acos(0.5),
+            'asin': integrate(Math.asin, -1, 1, 97),
+            'cos': integrate(Math.cos, 0, Math.PI, 97),
+            'largeCos': Math.cos(1e20),
+            'largeSin': Math.sin(1e20),
+            'largeTan': Math.tan(1e20),
+            'sin': integrate(Math.sin, -Math.PI, Math.PI, 97),
+            'tan': integrate(Math.tan, 0, 2 * Math.PI, 97),
+        }
+    );
+    });
+}

package/src/components/permissions/{permissions.ts → index.ts}

@@ -1,6 +1,7 @@
 import { componentInterface, includeComponent } from '../../factory';
 import { mostFrequentValuesInArrayOfDictionaries } from '../../utils/getMostFrequent';
 import { options } from '../../fingerprint/options';
+import { getBrowser } from '../system/browser';
 
 let permission_keys: PermissionName[];
 function initializePermissionKeys() {
@@ -27,8 +28,12 @@ function initializePermissionKeys() {
     ] as PermissionName[];
 }
 
-export default async function getBrowserPermissions(): Promise<componentInterface> {
+export default async function getPermissions(): Promise<componentInterface> {
     initializePermissionKeys();
+    const browser = getBrowser();
+    if (browser.name.toLowerCase() === 'safari') { // removing from Safari due to iFrame handling
+        permission_keys = permission_keys.filter((key) => !['camera', 'geolocation', 'microphone'].includes(key));
+    }
     const permissionPromises: Promise<componentInterface>[] = Array.from({length: options?.retries || 3}, () => getBrowserPermissionsOnce() );
     return Promise.all(permissionPromises).then((resolvedPermissions) => {
         const permission = mostFrequentValuesInArrayOfDictionaries(resolvedPermissions, permission_keys);
@@ -53,6 +58,4 @@ async function getBrowserPermissionsOnce(): Promise<componentInterface> {
     }
 
     return permissionStatus;
-}
-
-includeComponent("permissions", getBrowserPermissions);
+}

package/src/components/plugins/{plugins.ts → index.ts}

@@ -1,6 +1,6 @@
 import { componentInterface, includeComponent } from '../../factory'
 
-export default function getInstalledPlugins(): Promise<componentInterface> {
+export default function getPlugins(): Promise<componentInterface> {
     const plugins: string[] = [];
   
     if (navigator.plugins) {
@@ -17,6 +17,4 @@ export default function getInstalledPlugins(): Promise<componentInterface> {
         }
       );
   });
-  }
-  
-  includeComponent('plugins', getInstalledPlugins);
+  }

package/src/components/screen/{screen.ts → index.ts}

@@ -1,6 +1,6 @@
 import { componentInterface, includeComponent } from '../../factory';
 
-function screenDetails(): Promise<componentInterface> {
+export default function getScreen(): Promise<componentInterface> {
     return new Promise((resolve) => {
         resolve(
             {
@@ -41,6 +41,4 @@ function matchMedias(): string[] {
         })
     });
     return results;
-}
-
-includeComponent('screen', screenDetails);
+}

package/src/components/system/{system.ts → index.ts}

@@ -1,21 +1,26 @@
 import { componentInterface, includeComponent } from '../../factory';
 import { getBrowser } from './browser'
 
-function getSystemDetails(): Promise<componentInterface> {
+export default function getSystem(): Promise<componentInterface> {
     return new Promise((resolve) => {
         const browser = getBrowser()
-        resolve( {
+
+        const result: componentInterface = {
         'platform': window.navigator.platform,
-        'cookieEnabled': window.navigator.cookieEnabled,
         'productSub': navigator.productSub,
         'product': navigator.product,
         'useragent': navigator.userAgent,
         'hardwareConcurrency': navigator.hardwareConcurrency,
         'browser': {'name': browser.name, 'version': browser.version },
-        'applePayVersion': getApplePayVersion()
+        }
+        // Safari handles these differently in an iFrame so removing them from components
+        if (browser.name.toLowerCase() !== 'safari') {
+            result['applePayVersion'] = getApplePayVersion();
+            result['cookieEnabled'] = window.navigator.cookieEnabled;
+        }
+        resolve(result);
     });
-});
-}
+};
 
 /**
  * @returns applePayCanMakePayments: boolean, applePayMaxSupportedVersion: number
@@ -34,7 +39,4 @@ function getApplePayVersion(): number {
         }
     }
     return 0
-}
-
-includeComponent('system', getSystemDetails);
-
+}

package/src/components/webgl/{webgl.ts → index.ts}

@@ -16,7 +16,7 @@ function initializeCanvasAndWebGL() {
   }
 }
 
-async function createWebGLFingerprint(): Promise<componentInterface> {
+export default async function getWebGL(): Promise<componentInterface> {
   initializeCanvasAndWebGL();
   
   try {
@@ -32,7 +32,7 @@ async function createWebGLFingerprint(): Promise<componentInterface> {
     //const imageData = createWebGLImageData()
 
     return {
-      'commonImageHash': hash(commonImageData.data.toString()).toString(),
+      'commonPixelsHash': hash(commonImageData.data.toString()).toString(),
     }
   } catch (error) {
     return {
@@ -143,6 +143,4 @@ function createWebGLImageData(): ImageData {
       gl.clearColor(0.0, 0.0, 0.0, 0.0);
     }
   }
-}
-
-  includeComponent('webgl', createWebGLFingerprint);
+}

package/src/factory.ts

@@ -4,21 +4,53 @@
  * 
  */
 
-import { options, optionsInterface } from './fingerprint/options';
+import { optionsInterface } from './fingerprint/options';
+//import { getComponentPromises } from './fingerprint/tm_functions';
+
+// Import all built-in component functions
+import getAudio from "./components/audio";
+import getCanvas from "./components/canvas";
+import getFonts from "./components/fonts";
+import getHardware from "./components/hardware";
+import getLocales from "./components/locales";
+import getMath from "./components/math";
+import getPermissions from "./components/permissions";
+import getPlugins from "./components/plugins";
+import getScreen from "./components/screen";
+import getSystem from "./components/system";
+import getWebGL from "./components/webgl";
+
+/**
+ * @description key->function map of built-in components. Do not call the function here.
+ */
+export const tm_component_promises = {
+    'audio': getAudio,
+    'canvas': getCanvas,
+    'fonts': getFonts,
+    'hardware': getHardware,
+    'locales': getLocales,
+    'math': getMath,
+    'permissions': getPermissions,
+    'plugins': getPlugins,
+    'screen': getScreen,
+    'system': getSystem,
+    'webgl': getWebGL
+};
 
 // the component interface is the form of the JSON object the function's promise must return
 export interface componentInterface {
     [key: string]: string | string[] | number | boolean | componentInterface;
-}
+};
 
 
 // The component function's interface is simply the promise of the above
 export interface componentFunctionInterface {
-    (): Promise<componentInterface>;
+    (options?: optionsInterface): Promise<componentInterface | null>;
 }
 
 // components include a dictionary of name: function.
- export const components: {[name: string]: componentFunctionInterface} = {};
+// Renamed to customComponents for clarity; this is for user-registered components.
+export const customComponents: {[name: string]: componentFunctionInterface | null} = {};
 
 //In case a promise time-outs, this is what we use as the value in place
 export const timeoutInstance: componentInterface = {
@@ -30,29 +62,8 @@ export const timeoutInstance: componentInterface = {
  * in the fingerprint.
  * @param {string} name - the name identifier of the component
  * @param {componentFunctionInterface} creationFunction - the function that implements the component
- * @returns 
+ * @returns nothing
  */ 
-export const includeComponent = (name:string, creationFunction: componentFunctionInterface) => {
-    if (typeof window !== 'undefined')
-        components[name] = creationFunction;
-}
-
-/**
- * The function turns the map of component functions to a map of Promises when called
- * @returns {[name: string]: <Promise>componentInterface} 
- */
-export const getComponentPromises = () => {
-    return Object.fromEntries(
-        Object.entries(components)
-            .filter(([key]) => {
-                return !options?.exclude?.includes(key)}
-                )
-            .filter(([key]) => {
-                return options?.include?.some(e => e.includes('.'))
-                    ? options?.include?.some(e => e.startsWith(key))
-                    : options?.include?.length === 0 || options?.include?.includes(key)
-            }
-                    )
-            .map(([key, value]) => [key, value()])
-    );
-}
+export const includeComponent = (name:string, creationFunction: componentFunctionInterface, options?: optionsInterface) => {
+    customComponents[name] = creationFunction;
+};

package/src/fingerprint/functions.test.ts

@@ -1,5 +1,6 @@
-import {componentInterface} from '../factory'
-import {filterFingerprintData} from './functions'
+import { componentInterface } from '../factory'
+import { filterThumbmarkData } from '../utils/filterComponents'
+import { defaultOptions } from './options';
 
 const test_components: componentInterface = {
     'one': '1',
@@ -9,26 +10,30 @@ const test_components: componentInterface = {
 
 describe('component filtering tests', () => {
     test("excluding top level works", () => {
-        expect(filterFingerprintData(test_components, ['one'], [])).toMatchObject({
+        expect(filterThumbmarkData(test_components, 
+            { ...defaultOptions, ...{ exclude: ['one']} }
+        )).toMatchObject({
             'two': 2, 'three': {'a': true, 'b': false}
         })
     });
     test("including top level works", () => {
-        expect(filterFingerprintData(test_components, [], ['one', 'two'])).toMatchObject({
+        expect(filterThumbmarkData(test_components, { ...defaultOptions, ...{ include: ['one', 'two']} })).toMatchObject({
             'one': '1', 'two': 2
         })
     });
     test("excluding low-level works", () => {
-        expect(filterFingerprintData(test_components, ['two', 'three.a'], [])).toMatchObject({
+        expect(filterThumbmarkData(test_components,
+            { ...defaultOptions, ...{ exclude: ['two', 'three.a']} }
+        )).toMatchObject({
             'one': '1',
             'three': {'b': false}
         })
     });
     test("including low-level works", () => {
-        expect(filterFingerprintData(test_components, [], ['one', 'three.b'])).toMatchObject({
+        expect(filterThumbmarkData(test_components,
+            { ...defaultOptions, ...{ include: ['one', 'three.b']} })).toMatchObject({
             'one': '1',
             'three': {'b': false}
         })
     });
-
 });