clarity-js 0.7.65 → 0.7.67

package/src/data/compress.ts

@@ -1,31 +1,31 @@
-import { Constant } from "@clarity-types/data";
-
-const supported = Constant.CompressionStream in window;
-
-export default async function(input: string): Promise<Uint8Array> {
-    try {
-        if (supported) {
-            // Create a readable stream from given input string and
-            // pipe it through text encoder and compression stream to gzip it
-            const stream = new ReadableStream({async start(controller) {
-                controller.enqueue(input);
-                controller.close();
-            }}).pipeThrough(new TextEncoderStream()).pipeThrough(new window[Constant.CompressionStream]("gzip"));
-            return new Uint8Array(await read(stream));
-        }
-    } catch { /* do nothing */ }
-    return null;
-}
-
-async function read(stream: ReadableStream): Promise<number[]> {
-    const reader = stream.getReader();
-    const chunks:number[] = [];
-    let done = false;
-    let value: number[] = [];
-    while (!done) {
-      ({ done, value } = await reader.read());
-      if (done) { return chunks; }
-      chunks.push(...value);
-    }
-    return chunks;
-}
+import { Constant } from "@clarity-types/data";
+
+const supported = Constant.CompressionStream in window;
+
+export default async function(input: string): Promise<Uint8Array> {
+    try {
+        if (supported) {
+            // Create a readable stream from given input string and
+            // pipe it through text encoder and compression stream to gzip it
+            const stream = new ReadableStream({async start(controller) {
+                controller.enqueue(input);
+                controller.close();
+            }}).pipeThrough(new TextEncoderStream()).pipeThrough(new window[Constant.CompressionStream]("gzip"));
+            return new Uint8Array(await read(stream));
+        }
+    } catch { /* do nothing */ }
+    return null;
+}
+
+async function read(stream: ReadableStream): Promise<number[]> {
+    const reader = stream.getReader();
+    const chunks:number[] = [];
+    let done = false;
+    let value: number[] = [];
+    while (!done) {
+      ({ done, value } = await reader.read());
+      if (done) { return chunks; }
+      chunks.push(...value);
+    }
+    return chunks;
+}

package/src/data/consent.ts

@@ -1,21 +1,21 @@
-import { Dimension } from "@clarity-types/data";
-import * as dimension from "@src/data/dimension";
-
-const enum ConsentType {
-    None = 0,
-    Implicit = 1,
-    General = 2
-}
-
-export function config(track: boolean): void {
-    trackConsent(track ? ConsentType.Implicit : ConsentType.None);
-}
-
-// When we get consent signal as false, we restart the service and track config as false.
-export function consent(): void {
-    trackConsent(ConsentType.General);
-}
-
-function trackConsent(consent: ConsentType): void {
-    dimension.log(Dimension.Consent, consent.toString());
+import { Dimension } from "@clarity-types/data";
+import * as dimension from "@src/data/dimension";
+
+const enum ConsentType {
+    None = 0,
+    Implicit = 1,
+    General = 2
+}
+
+export function config(track: boolean): void {
+    trackConsent(track ? ConsentType.Implicit : ConsentType.None);
+}
+
+// When we get consent signal as false, we restart the service and track config as false.
+export function consent(): void {
+    trackConsent(ConsentType.General);
+}
+
+function trackConsent(consent: ConsentType): void {
+    dimension.log(Dimension.Consent, consent.toString());
 }

package/src/data/custom.ts

@@ -1,23 +1,23 @@
-import { Constant, CustomData, Event } from "@clarity-types/data";
-import * as core from "@src/core";
-import encode from "./encode";
-
-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 === 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);
-        
-    }
-}
+import { Constant, CustomData, Event } from "@clarity-types/data";
+import * as core from "@src/core";
+import encode from "./encode";
+
+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 === 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,53 +1,53 @@
-import { Check, Event, Dimension, DimensionData, Setting } from "@clarity-types/data";
-import * as limit from "@src/data/limit";
-import encode from "./encode";
-
-export let data: DimensionData = null;
-export let updates: DimensionData = null;
-let limited = false;
-
-export function start(): void {
-    data = {};
-    updates = {};
-    limited = false;
-}
-
-export function stop(): void {
-    data = {};
-    updates = {};
-    limited = false;
-}
-
-export function log(dimension: Dimension, value: string): void {
-    // Check valid value before moving ahead
-    if (value) {
-        // Ensure received value is casted into a string if it wasn't a string to begin with
-        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); 
-                }
-                return;
-            }
-
-            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] = []; }
-            updates[dimension].push(value);
-        }
-    }
-}
-
-export function compute(): void {
-    encode(Event.Dimension);
-}
-
-export function reset(): void {
-    updates = {};
-    limited = false;
-}
+import { Check, Event, Dimension, DimensionData, Setting } from "@clarity-types/data";
+import * as limit from "@src/data/limit";
+import encode from "./encode";
+
+export let data: DimensionData = null;
+export let updates: DimensionData = null;
+let limited = false;
+
+export function start(): void {
+    data = {};
+    updates = {};
+    limited = false;
+}
+
+export function stop(): void {
+    data = {};
+    updates = {};
+    limited = false;
+}
+
+export function log(dimension: Dimension, value: string): void {
+    // Check valid value before moving ahead
+    if (value) {
+        // Ensure received value is casted into a string if it wasn't a string to begin with
+        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); 
+                }
+                return;
+            }
+
+            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] = []; }
+            updates[dimension].push(value);
+        }
+    }
+}
+
+export function compute(): void {
+    encode(Event.Dimension);
+}
+
+export function reset(): void {
+    updates = {};
+    limited = false;
+}

package/src/data/encode.ts

@@ -1,127 +1,134 @@
-import { Event, Token } from "@clarity-types/data";
-import { time } from "@src/core/time";
-import * as baseline from "@src/data/baseline";
-import * as custom from "@src/data/custom";
-import * as dimension from "@src/data/dimension";
-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 {
-    let t = time();
-    let tokens: Token[] = [t, event]; 
-    switch (event) {
-        case Event.Baseline:
-            let b = baseline.state;
-            if (b) {
-                tokens = [b.time, b.event];
-                tokens.push(b.data.visible);
-                tokens.push(b.data.docWidth);
-                tokens.push(b.data.docHeight);
-                tokens.push(b.data.screenWidth);
-                tokens.push(b.data.screenHeight);
-                tokens.push(b.data.scrollX);
-                tokens.push(b.data.scrollY);
-                tokens.push(b.data.pointerX);
-                tokens.push(b.data.pointerY);
-                tokens.push(b.data.activityTime);
-                tokens.push(b.data.scrollTime);
-                queue(tokens, false);
-            }
-            baseline.reset();
-            break;
-        case Event.Ping:
-            tokens.push(ping.data.gap);
-            queue(tokens);
-            break;
-        case Event.Limit:
-            tokens.push(limit.data.check);
-            queue(tokens, false);
-            break;
-        case Event.Upgrade:
-            tokens.push(upgrade.data.key);
-            queue(tokens);
-            break;
-        case Event.Upload:
-            tokens.push(track.sequence);
-            tokens.push(track.attempts);
-            tokens.push(track.status);
-            queue(tokens, false);
-            break;
-        case Event.Custom:
-            // not all custom events have a key - if it wasn't passed server handles just value
-            custom.data.key && tokens.push(custom.data.key);
-            tokens.push(custom.data.value);
-            queue(tokens);
-            break;
-        case Event.Variable:
-            let variableKeys = Object.keys(variable.data);
-            if (variableKeys.length > 0) {
-                for (let v of variableKeys) {
-                    tokens.push(v);
-                    tokens.push(variable.data[v]);
-                }
-                variable.reset();
-                queue(tokens, false);
-            }
-            break;
-        case Event.Metric:
-            let metricKeys = Object.keys(metric.updates);
-            if (metricKeys.length > 0) {
-                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.
-                    tokens.push(Math.round(metric.updates[m]));
-                }
-                metric.reset();
-                queue(tokens, false);
-            }
-            break;
-        case Event.Dimension:
-            let dimensionKeys = Object.keys(dimension.updates);
-            if (dimensionKeys.length > 0) {
-                for (let d of dimensionKeys) {
-                    let key = parseInt(d, 10);
-                    tokens.push(key);
-                    tokens.push(dimension.updates[d]);
-                }
-                dimension.reset();
-                queue(tokens, false);
-            }
-            break;
-        case Event.Summary:
-            let eventKeys = Object.keys(summary.data);
-            if (eventKeys.length > 0) {
-                for (let e of eventKeys) {
-                    let key = parseInt(e, 10);
-                    tokens.push(key);
-                    tokens.push([].concat(...summary.data[e]));
-                }
-                summary.reset();
-                queue(tokens, false);
-            }
-            break;
-        case Event.Extract:
-            let extractKeys = extract.keys;
-            extractKeys.forEach((e => {
-                tokens.push(e);
-                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);
-    }
-}
+import { Event, Token } from "@clarity-types/data";
+import { time } from "@src/core/time";
+import * as baseline from "@src/data/baseline";
+import * as custom from "@src/data/custom";
+import * as dimension from "@src/data/dimension";
+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 {
+    let t = time();
+    let tokens: Token[] = [t, event]; 
+    switch (event) {
+        case Event.Baseline:
+            let b = baseline.state;
+            if (b) {
+                tokens = [b.time, b.event];
+                tokens.push(b.data.visible);
+                tokens.push(b.data.docWidth);
+                tokens.push(b.data.docHeight);
+                tokens.push(b.data.screenWidth);
+                tokens.push(b.data.screenHeight);
+                tokens.push(b.data.scrollX);
+                tokens.push(b.data.scrollY);
+                tokens.push(b.data.pointerX);
+                tokens.push(b.data.pointerY);
+                tokens.push(b.data.activityTime);
+                tokens.push(b.data.scrollTime);
+                tokens.push(b.data.pointerTime);
+                tokens.push(b.data.moveX);
+                tokens.push(b.data.moveY);
+                tokens.push(b.data.moveTime);
+                tokens.push(b.data.downX);
+                tokens.push(b.data.downY);
+                tokens.push(b.data.downTime);
+                queue(tokens, false);
+            }
+            baseline.reset();
+            break;
+        case Event.Ping:
+            tokens.push(ping.data.gap);
+            queue(tokens);
+            break;
+        case Event.Limit:
+            tokens.push(limit.data.check);
+            queue(tokens, false);
+            break;
+        case Event.Upgrade:
+            tokens.push(upgrade.data.key);
+            queue(tokens);
+            break;
+        case Event.Upload:
+            tokens.push(track.sequence);
+            tokens.push(track.attempts);
+            tokens.push(track.status);
+            queue(tokens, false);
+            break;
+        case Event.Custom:
+            // not all custom events have a key - if it wasn't passed server handles just value
+            custom.data.key && tokens.push(custom.data.key);
+            tokens.push(custom.data.value);
+            queue(tokens);
+            break;
+        case Event.Variable:
+            let variableKeys = Object.keys(variable.data);
+            if (variableKeys.length > 0) {
+                for (let v of variableKeys) {
+                    tokens.push(v);
+                    tokens.push(variable.data[v]);
+                }
+                variable.reset();
+                queue(tokens, false);
+            }
+            break;
+        case Event.Metric:
+            let metricKeys = Object.keys(metric.updates);
+            if (metricKeys.length > 0) {
+                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.
+                    tokens.push(Math.round(metric.updates[m]));
+                }
+                metric.reset();
+                queue(tokens, false);
+            }
+            break;
+        case Event.Dimension:
+            let dimensionKeys = Object.keys(dimension.updates);
+            if (dimensionKeys.length > 0) {
+                for (let d of dimensionKeys) {
+                    let key = parseInt(d, 10);
+                    tokens.push(key);
+                    tokens.push(dimension.updates[d]);
+                }
+                dimension.reset();
+                queue(tokens, false);
+            }
+            break;
+        case Event.Summary:
+            let eventKeys = Object.keys(summary.data);
+            if (eventKeys.length > 0) {
+                for (let e of eventKeys) {
+                    let key = parseInt(e, 10);
+                    tokens.push(key);
+                    tokens.push([].concat(...summary.data[e]));
+                }
+                summary.reset();
+                queue(tokens, false);
+            }
+            break;
+        case Event.Extract:
+            let extractKeys = extract.keys;
+            extractKeys.forEach((e => {
+                tokens.push(e);
+                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);
+    }
+}

package/src/data/envelope.ts

@@ -1,53 +1,53 @@
-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: ''
-  };
-}
-
-export function stop(): void {
-    data = null;
-}
-
-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
-  ];
-}
+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: ''
+  };
+}
+
+export function stop(): void {
+    data = null;
+}
+
+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
+  ];
+}