@ginger-ai/ginger-js 0.0.1

package/src/device/utils/ephemeralIFrame.ts

@@ -0,0 +1,35 @@
+export async function ephemeralIFrame(callback: ({ iframe }: { iframe: Document }) => void): Promise<any> {
+
+    while (!document.body) {
+      await wait(50)
+    }
+    const iframe = document.createElement('iframe')
+    iframe.setAttribute('frameBorder', '0')
+
+    const style = iframe.style
+    style.setProperty('position','fixed');
+    style.setProperty('display', 'block', 'important')
+    style.setProperty('visibility', 'visible')
+    style.setProperty('border', '0');
+    style.setProperty('opacity','0');
+    
+    iframe.src = 'about:blank'
+    document.body.appendChild(iframe)
+  
+    const iframeDocument = iframe.contentDocument || iframe.contentWindow?.document;
+    if (!iframeDocument) {
+      throw new Error('Iframe document is not accessible');
+    }
+  
+    // Execute the callback function with access to the iframe's document
+    callback({ iframe: iframeDocument });
+  
+    // Clean up after running the callback
+    setTimeout(() => {
+      document.body.removeChild(iframe);
+    }, 0);
+  }
+
+  export function wait<T = void>(durationMs: number, resolveWith?: T): Promise<T> {
+    return new Promise((resolve) => setTimeout(resolve, durationMs, resolveWith))
+  }

package/src/device/utils/getMostFrequent.ts

@@ -0,0 +1,39 @@
+function mostFrequentValue(arr: any[]): any | null {
+    if (arr.length === 0) {
+      return null; // Return null for an empty array
+    }
+  
+    const frequencyMap: { [key: string]: number } = {};
+  
+    // Count occurrences of each element in the array
+    arr.forEach((element) => {
+      const key = String(element);
+      frequencyMap[key] = (frequencyMap[key] || 0) + 1;
+    });
+  
+    let mostFrequent: any = arr[0]; // Assume the first element is the most frequent
+    let highestFrequency = 1; // Frequency of the assumed most frequent element
+  
+    // Find the element with the highest frequency
+    Object.keys(frequencyMap).forEach((key) => {
+      if (frequencyMap[key] > highestFrequency) {
+        mostFrequent = key;
+        highestFrequency = frequencyMap[key];
+      }
+    });
+  
+    return mostFrequent;
+  }
+
+export function mostFrequentValuesInArrayOfDictionaries(arr: { [key: string]: any }[], keys: string[]): { [key: string]: any } {
+    const result: { [key: string]: any } = {};
+  
+    keys.forEach((key) => {
+      const valuesForKey = arr.map((obj) => (key in obj ? obj[key] : undefined)).filter((val) => val !== undefined);
+      const mostFrequentValueForKey = mostFrequentValue(valuesForKey);
+      if (mostFrequentValueForKey)
+        result[key] = mostFrequentValueForKey;
+    });
+  
+    return result;
+  }

package/src/device/utils/hash.ts

@@ -0,0 +1,202 @@
+/**
+ * This code is taken from https://github.com/LinusU/murmur-128/blob/master/index.js
+ * But instead of dependencies to encode-utf8 and fmix, I've implemented them here.
+ */
+
+function encodeUtf8(text: string): any {
+  const encoder = new TextEncoder();
+  return encoder.encode(text).buffer;
+}
+  
+function fmix (input : number) : number {
+  input ^= (input >>> 16)
+  input = Math.imul(input, 0x85ebca6b)
+  input ^= (input >>> 13)
+  input = Math.imul(input, 0xc2b2ae35)
+  input ^= (input >>> 16)
+
+  return (input >>> 0)
+}
+  
+const C = new Uint32Array([
+  0x239b961b,
+  0xab0e9789,
+  0x38b34ae5,
+  0xa1e38b93
+])
+  
+function rotl (m : number, n : number) : number {
+  return (m << n) | (m >>> (32 - n))
+}
+  
+function body (key : ArrayBuffer, hash : Uint32Array) {
+  const blocks = (key.byteLength / 16) | 0
+  const view32 = new Uint32Array(key, 0, blocks * 4)
+
+  for (let i = 0; i < blocks; i++) {
+      const k = view32.subarray(i * 4, (i + 1) * 4)
+
+      k[0] = Math.imul(k[0], C[0])
+      k[0] = rotl(k[0], 15)
+      k[0] = Math.imul(k[0], C[1])
+
+      hash[0] = (hash[0] ^ k[0])
+      hash[0] = rotl(hash[0], 19)
+      hash[0] = (hash[0] + hash[1])
+      hash[0] = Math.imul(hash[0], 5) + 0x561ccd1b
+
+      k[1] = Math.imul(k[1], C[1])
+      k[1] = rotl(k[1], 16)
+      k[1] = Math.imul(k[1], C[2])
+
+      hash[1] = (hash[1] ^ k[1])
+      hash[1] = rotl(hash[1], 17)
+      hash[1] = (hash[1] + hash[2])
+      hash[1] = Math.imul(hash[1], 5) + 0x0bcaa747
+
+      k[2] = Math.imul(k[2], C[2])
+      k[2] = rotl(k[2], 17)
+      k[2] = Math.imul(k[2], C[3])
+
+      hash[2] = (hash[2] ^ k[2])
+      hash[2] = rotl(hash[2], 15)
+      hash[2] = (hash[2] + hash[3])
+      hash[2] = Math.imul(hash[2], 5) + 0x96cd1c35
+
+      k[3] = Math.imul(k[3], C[3])
+      k[3] = rotl(k[3], 18)
+      k[3] = Math.imul(k[3], C[0])
+
+      hash[3] = (hash[3] ^ k[3])
+      hash[3] = rotl(hash[3], 13)
+      hash[3] = (hash[3] + hash[0])
+      hash[3] = Math.imul(hash[3], 5) + 0x32ac3b17
+  }
+}
+  
+function tail (key : ArrayBuffer, hash : Uint32Array) {
+    const blocks = (key.byteLength / 16) | 0
+    const reminder = (key.byteLength % 16)
+  
+    const k = new Uint32Array(4)
+    const tail = new Uint8Array(key, blocks * 16, reminder)
+  
+    switch (reminder) {
+      case 15:
+        k[3] = (k[3] ^ (tail[14] << 16))
+        break// fallthrough
+      case 14:
+        k[3] = (k[3] ^ (tail[13] << 8))
+        break// fallthrough
+      case 13:
+        k[3] = (k[3] ^ (tail[12] << 0))
+  
+        k[3] = Math.imul(k[3], C[3])
+        k[3] = rotl(k[3], 18)
+        k[3] = Math.imul(k[3], C[0])
+        hash[3] = (hash[3] ^ k[3])
+        break
+        // fallthrough
+      case 12:
+        k[2] = (k[2] ^ (tail[11] << 24))
+        break// fallthrough
+      case 11:
+        k[2] = (k[2] ^ (tail[10] << 16))
+        break// fallthrough
+      case 10:
+        k[2] = (k[2] ^ (tail[9] << 8))
+        break// fallthrough
+      case 9:
+        k[2] = (k[2] ^ (tail[8] << 0))
+  
+        k[2] = Math.imul(k[2], C[2])
+        k[2] = rotl(k[2], 17)
+        k[2] = Math.imul(k[2], C[3])
+        hash[2] = (hash[2] ^ k[2])
+        break
+        // fallthrough
+      case 8:
+        k[1] = (k[1] ^ (tail[7] << 24))
+        break// fallthrough
+      case 7:
+        k[1] = (k[1] ^ (tail[6] << 16))
+        break// fallthrough
+      case 6:
+        k[1] = (k[1] ^ (tail[5] << 8))
+        break// fallthrough
+      case 5:
+        k[1] = (k[1] ^ (tail[4] << 0))
+  
+        k[1] = Math.imul(k[1], C[1])
+        k[1] = rotl(k[1], 16)
+        k[1] = Math.imul(k[1], C[2])
+        hash[1] = (hash[1] ^ k[1])
+        break
+        // fallthrough
+      case 4:
+        k[0] = (k[0] ^ (tail[3] << 24))
+        break// fallthrough
+      case 3:
+        k[0] = (k[0] ^ (tail[2] << 16))
+        break// fallthrough
+      case 2:
+        k[0] = (k[0] ^ (tail[1] << 8))
+        break// fallthrough
+      case 1:
+        k[0] = (k[0] ^ (tail[0] << 0))
+  
+        k[0] = Math.imul(k[0], C[0])
+        k[0] = rotl(k[0], 15)
+        k[0] = Math.imul(k[0], C[1])
+        hash[0] = (hash[0] ^ k[0])
+        break
+    }
+}
+  
+function finalize (key : ArrayBuffer, hash : Uint32Array) {
+    hash[0] = (hash[0] ^ key.byteLength)
+    hash[1] = (hash[1] ^ key.byteLength)
+    hash[2] = (hash[2] ^ key.byteLength)
+    hash[3] = (hash[3] ^ key.byteLength)
+  
+    hash[0] = (hash[0] + hash[1]) | 0
+    hash[0] = (hash[0] + hash[2]) | 0
+    hash[0] = (hash[0] + hash[3]) | 0
+  
+    hash[1] = (hash[1] + hash[0]) | 0
+    hash[2] = (hash[2] + hash[0]) | 0
+    hash[3] = (hash[3] + hash[0]) | 0
+  
+    hash[0] = fmix(hash[0])
+    hash[1] = fmix(hash[1])
+    hash[2] = fmix(hash[2])
+    hash[3] = fmix(hash[3])
+  
+    hash[0] = (hash[0] + hash[1]) | 0
+    hash[0] = (hash[0] + hash[2]) | 0
+    hash[0] = (hash[0] + hash[3]) | 0
+  
+    hash[1] = (hash[1] + hash[0]) | 0
+    hash[2] = (hash[2] + hash[0]) | 0
+    hash[3] = (hash[3] + hash[0]) | 0
+}
+  
+export function hash (key : ArrayBuffer | string, seed = 0) : string {
+    seed = (seed ? (seed | 0) : 0)
+  
+    if (typeof key === 'string') {
+      key = encodeUtf8(key)
+    }
+  
+    if (!(key instanceof ArrayBuffer)) {
+      throw new TypeError('Expected key to be ArrayBuffer or string')
+    }
+  
+    const hash = new Uint32Array([seed, seed, seed, seed])
+  
+    body(key, hash)
+    tail(key, hash)
+    finalize(key, hash)
+    const byteArray = new Uint8Array(hash.buffer);
+    return Array.from(byteArray).map(byte => byte.toString(16).padStart(2, '0')).join('');
+}

package/src/device/utils/misc.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts an error object to a plain object that can be used with `JSON.stringify`.
+ * If you just run `JSON.stringify(error)`, you'll get `'{}'`.
+ */
+export function errorToObject(error: Readonly<Error>): Record<string, unknown> {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack?.split('\n'),
+      // The fields are not enumerable, so TS is wrong saying that they will be overridden
+      ...(error as Omit<Error, 'name' | 'message'>),
+    }
+  }
+  
+  export function isFunctionNative(func: (...args: unknown[]) => unknown): boolean {
+    return /^function\s.*?\{\s*\[native code]\s*}$/.test(String(func))
+  }
+  

package/src/device/utils/raceAll.ts

@@ -0,0 +1,19 @@
+type DelayedPromise<T> = Promise<T>;
+
+export function delay<T>(t: number, val: T): DelayedPromise<T> {
+  return new Promise<T>((resolve) => {
+    setTimeout(() => resolve(val), t);
+  });
+}
+
+
+export interface RaceResult<T> {
+  value: T;
+  elapsed?: number;
+}
+
+export function raceAll<T>(promises: Promise<T>[], timeoutTime: number, timeoutVal: T): Promise<(T | undefined)[]> {
+  return Promise.all(promises.map((p) => {
+    return Promise.race([p, delay(timeoutTime, timeoutVal)]);
+  }));
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { generateRequestId, GingerHttpClient, HttpClient, GingerClientError, GingerError, pageVisibility} from "./core";
+export { fetchModules, buildInitialPayload } from "./device";
+export { GingerJsClient } from "./client";