clarity-js 0.8.12 → 0.8.14

package/src/data/baseline.ts

@@ -1,11 +1,11 @@
-import { BooleanFlag, Event } from "@clarity-types/data";
-import type { BaselineData, BaselineState } from "@clarity-types/data";
+import { Event, BooleanFlag } from "@clarity-types/data";
+import { BaselineData, BaselineState } from "@clarity-types/data";
 import { time } from "@src/core/time";
 import encode from "@src/data/encode";
 
 export let state: BaselineState = null;
 let buffer: BaselineData = null;
-let update = false;
+let update: boolean = false;
 
 export function start(): void {
     update = false;
@@ -16,65 +16,60 @@ export function reset(): void {
     // Baseline state holds the previous values - if it is updated in the current payload,
     // reset the state to current value after sending the previous state
     if (update) {
-        state = {
-            time: time(),
-            event: Event.Baseline,
-            data: {
-                visible: buffer.visible,
-                docWidth: buffer.docWidth,
-                docHeight: buffer.docHeight,
-                screenWidth: buffer.screenWidth,
-                screenHeight: buffer.screenHeight,
-                scrollX: buffer.scrollX,
-                scrollY: buffer.scrollY,
-                pointerX: buffer.pointerX,
-                pointerY: buffer.pointerY,
-                activityTime: buffer.activityTime,
-                scrollTime: buffer.scrollTime,
-                pointerTime: buffer.pointerTime,
-                moveX: buffer.moveX,
-                moveY: buffer.moveY,
-                moveTime: buffer.moveTime,
-                downX: buffer.downX,
-                downY: buffer.downY,
-                downTime: buffer.downTime,
-                upX: buffer.upX,
-                upY: buffer.upY,
-                upTime: buffer.upTime,
-                pointerPrevX: buffer.pointerPrevX,
-                pointerPrevY: buffer.pointerPrevY,
-                pointerPrevTime: buffer.pointerPrevTime,
-            },
+        state = { time: time(), event: Event.Baseline, data: {
+            visible: buffer.visible,
+            docWidth: buffer.docWidth,
+            docHeight: buffer.docHeight,
+            screenWidth: buffer.screenWidth,
+            screenHeight: buffer.screenHeight,
+            scrollX: buffer.scrollX,
+            scrollY: buffer.scrollY,
+            pointerX: buffer.pointerX,
+            pointerY: buffer.pointerY,
+            activityTime: buffer.activityTime,
+            scrollTime: buffer.scrollTime,
+            pointerTime: buffer.pointerTime,
+            moveX: buffer.moveX,
+            moveY: buffer.moveY,
+            moveTime: buffer.moveTime,
+            downX: buffer.downX,
+            downY: buffer.downY,
+            downTime: buffer.downTime,
+            upX: buffer.upX,
+            upY: buffer.upY,
+            upTime: buffer.upTime,
+            pointerPrevX: buffer.pointerPrevX,
+            pointerPrevY: buffer.pointerPrevY,
+            pointerPrevTime: buffer.pointerPrevTime,
+          }
         };
     }
-    buffer = buffer
-        ? buffer
-        : {
-              visible: BooleanFlag.True,
-              docWidth: 0,
-              docHeight: 0,
-              screenWidth: 0,
-              screenHeight: 0,
-              scrollX: 0,
-              scrollY: 0,
-              pointerX: 0,
-              pointerY: 0,
-              activityTime: 0,
-              scrollTime: 0,
-              pointerTime: undefined,
-              moveX: undefined,
-              moveY: undefined,
-              moveTime: undefined,
-              downX: undefined,
-              downY: undefined,
-              downTime: undefined,
-              upX: undefined,
-              upY: undefined,
-              upTime: undefined,
-              pointerPrevX: undefined,
-              pointerPrevY: undefined,
-              pointerPrevTime: undefined,
-          };
+    buffer = buffer ? buffer : {
+        visible: BooleanFlag.True,
+        docWidth: 0,
+        docHeight: 0,
+        screenWidth: 0,
+        screenHeight: 0,
+        scrollX: 0,
+        scrollY: 0,
+        pointerX: 0,
+        pointerY: 0,
+        activityTime: 0,
+        scrollTime: 0,
+        pointerTime: undefined,
+        moveX: undefined,
+        moveY: undefined,
+        moveTime: undefined,
+        downX: undefined,
+        downY: undefined,
+        downTime: undefined,
+        upX: undefined,
+        upY: undefined,
+        upTime: undefined,
+        pointerPrevX: undefined,
+        pointerPrevY: undefined,
+        pointerPrevTime: undefined,
+    };
 }
 
 export function track(event: Event, x: number, y: number, time?: number): void {

package/src/data/consent.ts

@@ -1,14 +1,19 @@
-import { Dimension } from "@clarity-types/data";
+import { ConsentData, Dimension, Event } from "@clarity-types/data";
 import * as dimension from "@src/data/dimension";
+import encode from "./encode";
+
+export let data: ConsentData = null;
+let updateConsent: boolean = true;
 
 const enum ConsentType {
     None = 0,
     Implicit = 1,
-    General = 2,
+    General = 2
 }
 
-export function config(track: boolean): void {
-    trackConsent(track ? ConsentType.Implicit : ConsentType.None);
+export function config(consent: ConsentData): void {
+    trackConsent(consent.analytics_Storage ? ConsentType.Implicit : ConsentType.None);
+    data = consent;
 }
 
 // When we get consent signal as false, we restart the service and track config as false.
@@ -19,3 +24,16 @@ export function consent(): void {
 function trackConsent(consent: ConsentType): void {
     dimension.log(Dimension.Consent, consent.toString());
 }
+
+export function consentv2(consent: ConsentData): void {
+    data = consent;
+    encode(Event.Consent);
+}
+
+// Compute function is called every upload, but we only want to send consent data once.
+export function compute(): void {
+    if (updateConsent) {
+        encode(Event.Consent);
+        updateConsent = false;
+    }
+}

package/src/data/custom.ts

@@ -1,4 +1,4 @@
-import { type CustomData, Event } from "@clarity-types/data";
+import { Constant, CustomData, Event } from "@clarity-types/data";
 import * as core from "@src/core";
 import encode from "./encode";
 
@@ -7,12 +7,17 @@ export let data: CustomData = null;
 // custom events allow 2 parameters or 1 parameter to be passed. If 2 are passed we
 // consider it a key value pair. If only 1 is passed we only consider the event to have a value.
 export function event(a: string, b: string): void {
-    if (core.active() && a && typeof a === "string" && a.length < 255) {
-        if (b && typeof b === "string" && b.length < 255) {
-            data = { key: a, value: b };
-        } else {
-            data = { value: a };
-        }
-        encode(Event.Custom);
+    if (core.active() &&
+        a &&
+        typeof a === Constant.String &&
+        a.length < 255
+        ) {
+            if (b && typeof b === Constant.String && b.length < 255) {
+                data = { key: a, value: b};
+            } else {
+                data = { value: a }
+            }
+            encode(Event.Custom);
+        
     }
 }

package/src/data/dimension.ts

@@ -1,4 +1,4 @@
-import { Check, type Dimension, type DimensionData, Event, Setting } from "@clarity-types/data";
+import { Check, Event, Dimension, DimensionData, Setting } from "@clarity-types/data";
 import * as limit from "@src/data/limit";
 import encode from "./encode";
 
@@ -18,20 +18,18 @@ export function stop(): void {
     limited = false;
 }
 
-export function log(dimension: Dimension, inputValue: string): void {
+export function log(dimension: Dimension, value: string): void {
     // Check valid value before moving ahead
-    if (inputValue) {
+    if (value) {
         // Ensure received value is casted into a string if it wasn't a string to begin with
-        const value = `${inputValue}`;
-        if (!(dimension in data)) {
-            data[dimension] = [];
-        }
+        value = `${value}`;
+        if (!(dimension in data)) { data[dimension] = []; }
         if (data[dimension].indexOf(value) < 0) {
             // Limit check to ensure we have a cap on number of dimensions we can collect
             if (data[dimension].length > Setting.CollectionLimit) {
                 if (!limited) {
                     limited = true;
-                    limit.trigger(Check.Collection);
+                    limit.trigger(Check.Collection); 
                 }
                 return;
             }
@@ -39,9 +37,7 @@ export function log(dimension: Dimension, inputValue: string): void {
             data[dimension].push(value);
             // If this is a new value, track it as part of updates object
             // This allows us to only send back new values in subsequent payloads
-            if (!(dimension in updates)) {
-                updates[dimension] = [];
-            }
+            if (!(dimension in updates)) { updates[dimension] = []; }
             updates[dimension].push(value);
         }
     }

package/src/data/encode.ts

@@ -1,23 +1,24 @@
-import { Event, type Token } from "@clarity-types/data";
+import { Event, Token } from "@clarity-types/data";
 import { time } from "@src/core/time";
 import * as baseline from "@src/data/baseline";
+import * as consent from "@src/data/consent";
 import * as custom from "@src/data/custom";
 import * as dimension from "@src/data/dimension";
-import * as extract from "@src/data/extract";
 import * as limit from "@src/data/limit";
 import * as metric from "@src/data/metric";
 import * as ping from "@src/data/ping";
 import * as summary from "@src/data/summary";
 import * as upgrade from "@src/data/upgrade";
 import * as variable from "@src/data/variable";
+import * as extract from "@src/data/extract";
 import { queue, track } from "./upload";
 
-export default function (event: Event): void {
-    const t = time();
-    let tokens: Token[] = [t, event];
+export default function(event: Event): void {
+    let t = time();
+    let tokens: Token[] = [t, event]; 
     switch (event) {
-        case Event.Baseline: {
-            const b = baseline.state;
+        case Event.Baseline:
+            let b = baseline.state;
             if (b) {
                 tokens = [b.time, b.event];
                 tokens.push(b.data.visible);
@@ -48,7 +49,6 @@ export default function (event: Event): void {
             }
             baseline.reset();
             break;
-        }
         case Event.Ping:
             tokens.push(ping.data.gap);
             queue(tokens);
@@ -73,10 +73,10 @@ export default function (event: Event): void {
             tokens.push(custom.data.value);
             queue(tokens);
             break;
-        case Event.Variable: {
-            const variableKeys = Object.keys(variable.data);
+        case Event.Variable:
+            let variableKeys = Object.keys(variable.data);
             if (variableKeys.length > 0) {
-                for (const v of variableKeys) {
+                for (let v of variableKeys) {
                     tokens.push(v);
                     tokens.push(variable.data[v]);
                 }
@@ -84,12 +84,11 @@ export default function (event: Event): void {
                 queue(tokens, false);
             }
             break;
-        }
-        case Event.Metric: {
-            const metricKeys = Object.keys(metric.updates);
+        case Event.Metric:
+            let metricKeys = Object.keys(metric.updates);
             if (metricKeys.length > 0) {
-                for (const m of metricKeys) {
-                    const key = Number.parseInt(m, 10);
+                for (let m of metricKeys) {
+                    let key = parseInt(m, 10);
                     tokens.push(key);
                     // For computation, we need microseconds precision that performance.now() API offers
                     // However, for data over the wire, we round it off to milliseconds precision.
@@ -99,12 +98,11 @@ export default function (event: Event): void {
                 queue(tokens, false);
             }
             break;
-        }
-        case Event.Dimension: {
-            const dimensionKeys = Object.keys(dimension.updates);
+        case Event.Dimension:
+            let dimensionKeys = Object.keys(dimension.updates);
             if (dimensionKeys.length > 0) {
-                for (const d of dimensionKeys) {
-                    const key = Number.parseInt(d, 10);
+                for (let d of dimensionKeys) {
+                    let key = parseInt(d, 10);
                     tokens.push(key);
                     tokens.push(dimension.updates[d]);
                 }
@@ -112,12 +110,11 @@ export default function (event: Event): void {
                 queue(tokens, false);
             }
             break;
-        }
-        case Event.Summary: {
-            const eventKeys = Object.keys(summary.data);
+        case Event.Summary:
+            let eventKeys = Object.keys(summary.data);
             if (eventKeys.length > 0) {
-                for (const e of eventKeys) {
-                    const key = Number.parseInt(e, 10);
+                for (let e of eventKeys) {
+                    let key = parseInt(e, 10);
                     tokens.push(key);
                     tokens.push([].concat(...summary.data[e]));
                 }
@@ -125,22 +122,27 @@ export default function (event: Event): void {
                 queue(tokens, false);
             }
             break;
-        }
-        case Event.Extract: {
-            const extractKeys = extract.keys;
-            for (const e of Array.from(extractKeys)) {
+        case Event.Extract:
+            let extractKeys = extract.keys;
+            extractKeys.forEach((e => {
                 tokens.push(e);
-                const token = [];
-                for (const d in extract.data[e]) {
-                    const key = Number.parseInt(d, 10);
+                let token = []
+                for (let d in extract.data[e]) {
+                    let key = parseInt(d, 10);
                     token.push(key);
                     token.push(extract.data[e][d]);
                 }
                 tokens.push(token);
-            }
-
+            }));
+            
             extract.reset();
             queue(tokens, false);
-        }
+        
+        case Event.Consent: 
+            tokens.push(consent.data.source);
+            tokens.push(consent.data.ad_Storage);
+            tokens.push(consent.data.analytics_Storage);
+            queue(tokens);
+            break;
     }
 }

package/src/data/envelope.ts

@@ -1,27 +1,27 @@
-import { ApplicationPlatform, BooleanFlag, type Envelope, type Token, Upload } from "@clarity-types/data";
-import * as scrub from "@src/core/scrub";
+import { BooleanFlag, Token, Upload, Envelope, ApplicationPlatform } from "@clarity-types/data";
 import { time } from "@src/core/time";
 import version from "@src/core/version";
 import * as metadata from "@src/data/metadata";
+import * as scrub from "@src/core/scrub";
 
 export let data: Envelope = null;
 
 export function start(): void {
-    const m = metadata.data;
-    data = {
-        version,
-        sequence: 0,
-        start: 0,
-        duration: 0,
-        projectId: m.projectId,
-        userId: m.userId,
-        sessionId: m.sessionId,
-        pageNum: m.pageNum,
-        upload: Upload.Async,
-        end: BooleanFlag.False,
-        applicationPlatform: ApplicationPlatform.WebApp,
-        url: "",
-    };
+  const m = metadata.data;
+  data = {
+    version,
+    sequence: 0,
+    start: 0,
+    duration: 0,
+    projectId: m.projectId,
+    userId: m.userId,
+    sessionId: m.sessionId,
+    pageNum: m.pageNum,
+    upload: Upload.Async,
+    end: BooleanFlag.False,
+    applicationPlatform: ApplicationPlatform.WebApp,
+    url: ''
+  };
 }
 
 export function stop(): void {
@@ -29,25 +29,25 @@ export function stop(): void {
 }
 
 export function envelope(last: boolean): Token[] {
-    data.start = data.start + data.duration;
-    data.duration = time() - data.start;
-    data.sequence++;
-    data.upload = last && "sendBeacon" in navigator ? Upload.Beacon : Upload.Async;
-    data.end = last ? BooleanFlag.True : BooleanFlag.False;
-    data.applicationPlatform = ApplicationPlatform.WebApp;
-    data.url = scrub.url(location.href, false, true);
-    return [
-        data.version,
-        data.sequence,
-        data.start,
-        data.duration,
-        data.projectId,
-        data.userId,
-        data.sessionId,
-        data.pageNum,
-        data.upload,
-        data.end,
-        data.applicationPlatform,
-        data.url,
-    ];
+  data.start = data.start + data.duration;
+  data.duration = time() - data.start;
+  data.sequence++;
+  data.upload = last && "sendBeacon" in navigator ? Upload.Beacon : Upload.Async;
+  data.end = last ? BooleanFlag.True : BooleanFlag.False;
+  data.applicationPlatform = ApplicationPlatform.WebApp;
+  data.url = scrub.url(location.href, false, true);
+  return [
+    data.version,
+    data.sequence,
+    data.start,
+    data.duration,
+    data.projectId,
+    data.userId,
+    data.sessionId,
+    data.pageNum,
+    data.upload,
+    data.end,
+    data.applicationPlatform,
+    data.url
+  ];
 }