clarity-js 0.8.1 → 0.8.2

package/src/data/metric.ts

@@ -1,51 +1,51 @@
-import { Event, Metric, MetricData } from "@clarity-types/data";
-import encode from "./encode";
-
-export let data: MetricData = null;
-export let updates: MetricData = null;
-
-export function start(): void {
-    data = {};
-    updates = {};
-    count(Metric.InvokeCount);
-}
-
-export function stop(): void {
-    data = {};
-    updates = {};
-}
-
-export function count(metric: Metric): void {
-    if (!(metric in data)) { data[metric] = 0; }
-    if (!(metric in updates)) { updates[metric] = 0; }
-    data[metric]++;
-    updates[metric]++;
-}
-
-export function sum(metric: Metric, value: number): void {
-    if (value !== null) { 
-        if (!(metric in data)) { data[metric] = 0; }
-        if (!(metric in updates)) { updates[metric] = 0; }
-        data[metric] += value;
-        updates[metric] += value;
-    }
-}
-
-export function max(metric: Metric, value: number): void {
-    // Ensure that we do not process null or NaN values
-    if (value !== null && isNaN(value) === false) { 
-        if (!(metric in data)) { data[metric] = 0; }
-        if (value > data[metric] || data[metric] === 0) {
-            updates[metric] = value;
-            data[metric] = value;
-        }
-    }
-}
-
-export function compute(): void {
-    encode(Event.Metric);
-}
-
-export function reset(): void {
-    updates = {};
-}
+import { Event, Metric, MetricData } from "@clarity-types/data";
+import encode from "./encode";
+
+export let data: MetricData = null;
+export let updates: MetricData = null;
+
+export function start(): void {
+    data = {};
+    updates = {};
+    count(Metric.InvokeCount);
+}
+
+export function stop(): void {
+    data = {};
+    updates = {};
+}
+
+export function count(metric: Metric): void {
+    if (!(metric in data)) { data[metric] = 0; }
+    if (!(metric in updates)) { updates[metric] = 0; }
+    data[metric]++;
+    updates[metric]++;
+}
+
+export function sum(metric: Metric, value: number): void {
+    if (value !== null) { 
+        if (!(metric in data)) { data[metric] = 0; }
+        if (!(metric in updates)) { updates[metric] = 0; }
+        data[metric] += value;
+        updates[metric] += value;
+    }
+}
+
+export function max(metric: Metric, value: number): void {
+    // Ensure that we do not process null or NaN values
+    if (value !== null && isNaN(value) === false) { 
+        if (!(metric in data)) { data[metric] = 0; }
+        if (value > data[metric] || data[metric] === 0) {
+            updates[metric] = value;
+            data[metric] = value;
+        }
+    }
+}
+
+export function compute(): void {
+    encode(Event.Metric);
+}
+
+export function reset(): void {
+    updates = {};
+}

package/src/data/ping.ts

@@ -1,36 +1,36 @@
-import { Event, PingData, Setting } from "@clarity-types/data";
-import { suspend } from "@src/core";
-import { time } from "@src/core/time";
-import { clearTimeout, setTimeout } from "@src/core/timeout";
-import encode from "./encode";
-
-export let data: PingData;
-let last = 0;
-let interval = 0;
-let timeout: number = null;
-
-export function start(): void {
-    interval = Setting.PingInterval;
-    last = 0;
-}
-
-export function reset(): void {
-    if (timeout) { clearTimeout(timeout); }
-    timeout = setTimeout(ping, interval);
-    last = time();
-}
-
-function ping(): void {
-    let now = time();
-    data = { gap: now - last };
-    encode(Event.Ping);
-    if (data.gap < Setting.PingTimeout) {
-        timeout = setTimeout(ping, interval);
-    } else { suspend(); }
-}
-
-export function stop(): void {
-    clearTimeout(timeout);
-    last = 0;
-    interval = 0;
-}
+import { Event, PingData, Setting } from "@clarity-types/data";
+import { suspend } from "@src/core";
+import { time } from "@src/core/time";
+import { clearTimeout, setTimeout } from "@src/core/timeout";
+import encode from "./encode";
+
+export let data: PingData;
+let last = 0;
+let interval = 0;
+let timeout: number = null;
+
+export function start(): void {
+    interval = Setting.PingInterval;
+    last = 0;
+}
+
+export function reset(): void {
+    if (timeout) { clearTimeout(timeout); }
+    timeout = setTimeout(ping, interval);
+    last = time();
+}
+
+function ping(): void {
+    let now = time();
+    data = { gap: now - last };
+    encode(Event.Ping);
+    if (data.gap < Setting.PingTimeout) {
+        timeout = setTimeout(ping, interval);
+    } else { suspend(); }
+}
+
+export function stop(): void {
+    clearTimeout(timeout);
+    last = 0;
+    interval = 0;
+}

package/src/data/signal.ts

@@ -1,30 +1,30 @@
-import { ClaritySignal, SignalCallback } from '@clarity-types/data';
-
-export let signalCallback: SignalCallback = null;
-
-export function signal(cb: SignalCallback): void {
-  signalCallback = cb;
-}
-
-function parseSignals(signalsPayload: string): ClaritySignal[] {
-  try{
-    const parsedSignals: ClaritySignal[] = JSON.parse(signalsPayload);
-    return parsedSignals;
-  }catch{
-    return []
-  }
-}
-
-export function signalsEvent(signalsPayload: string) {
-  try {
-    if (!signalCallback) {
-      return;
-    }
-    const signals = parseSignals(signalsPayload);
-    signals.forEach((signal) => {
-      signalCallback(signal);
-    });
-  } catch {
-    //do nothing
-  }
-}
+import { ClaritySignal, SignalCallback } from '@clarity-types/data';
+
+export let signalCallback: SignalCallback = null;
+
+export function signal(cb: SignalCallback): void {
+  signalCallback = cb;
+}
+
+function parseSignals(signalsPayload: string): ClaritySignal[] {
+  try{
+    const parsedSignals: ClaritySignal[] = JSON.parse(signalsPayload);
+    return parsedSignals;
+  }catch{
+    return []
+  }
+}
+
+export function signalsEvent(signalsPayload: string) {
+  try {
+    if (!signalCallback) {
+      return;
+    }
+    const signals = parseSignals(signalsPayload);
+    signals.forEach((signal) => {
+      signalCallback(signal);
+    });
+  } catch {
+    //do nothing
+  }
+}

package/src/data/summary.ts

@@ -1,34 +1,34 @@
-import { Event, SummaryData, Setting } from "@clarity-types/data";
-import encode from "./encode";
-
-export let data: SummaryData = null;
-
-export function start(): void {
-    data = {};
-}
-
-export function stop(): void {
-    data = {};
-}
-
-export function track(event: Event, time: number): void {
-    if (!(event in data)) {
-        data[event] = [[time, 0]];
-    } else {
-        let e = data[event];
-        let last = e[e.length - 1];
-        // Add a new entry only if the new event occurs after configured interval
-        // Otherwise, extend the duration of the previous entry
-        if (time - last[0] > Setting.SummaryInterval) {
-            data[event].push([time, 0]);
-        } else { last[1] = time - last[0]; }
-    }
-}
-
-export function compute(): void {
-    encode(Event.Summary);
-}
-
-export function reset(): void {
-    data = {};
-}
+import { Event, SummaryData, Setting } from "@clarity-types/data";
+import encode from "./encode";
+
+export let data: SummaryData = null;
+
+export function start(): void {
+    data = {};
+}
+
+export function stop(): void {
+    data = {};
+}
+
+export function track(event: Event, time: number): void {
+    if (!(event in data)) {
+        data[event] = [[time, 0]];
+    } else {
+        let e = data[event];
+        let last = e[e.length - 1];
+        // Add a new entry only if the new event occurs after configured interval
+        // Otherwise, extend the duration of the previous entry
+        if (time - last[0] > Setting.SummaryInterval) {
+            data[event].push([time, 0]);
+        } else { last[1] = time - last[0]; }
+    }
+}
+
+export function compute(): void {
+    encode(Event.Summary);
+}
+
+export function reset(): void {
+    data = {};
+}

package/src/data/token.ts

@@ -1,39 +1,39 @@
-import {Constant, Token} from "@clarity-types/data";
-
-// Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
-// The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
-// If so, it replaces the token with its reference (index). This helps us save bytes by not repeating the same value twice.
-// E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
-// Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
-// Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
-export default function(tokens: Token[]): Token[] {
-    let output: Token[] = [];
-    let lookup: {[key: string]: number} = {};
-    let pointer = 0;
-    let reference = null;
-    for (let i = 0; i < tokens.length; i++) {
-        // Only optimize for string values
-        if (typeof tokens[i] === Constant.String) {
-            let token = tokens[i] as string;
-            let index = lookup[token] || -1;
-            if (index >= 0) {
-                if (reference) { reference.push(index); } else {
-                    reference = [index];
-                    output.push(reference);
-                    pointer++;
-                }
-            } else {
-                reference = null;
-                output.push(token);
-                lookup[token] = pointer++;
-            }
-        } else {
-            // If the value is anything other than string, append it as it is to the output array
-            // And, also increment the pointer to stay in sync with output array
-            reference = null;
-            output.push(tokens[i]);
-            pointer++;
-        }
-    }
-    return output;
-}
+import {Constant, Token} from "@clarity-types/data";
+
+// Following code takes an array of tokens and transforms it to optimize for repeating tokens and make it efficient to send over the wire
+// The way it works is that it iterate over all tokens and checks if the current token was already seen in the tokens array so far
+// If so, it replaces the token with its reference (index). This helps us save bytes by not repeating the same value twice.
+// E.g. If tokens array is: ["hello", "world", "coding", "language", "world", "language", "example"]
+// Then the resulting tokens array after following code execution would be: ["hello", "world", "coding", "language", [1, 3], "example"]
+// Where [1,3] points to tokens[1] => "world" and tokens[3] => "language"
+export default function(tokens: Token[]): Token[] {
+    let output: Token[] = [];
+    let lookup: {[key: string]: number} = {};
+    let pointer = 0;
+    let reference = null;
+    for (let i = 0; i < tokens.length; i++) {
+        // Only optimize for string values
+        if (typeof tokens[i] === Constant.String) {
+            let token = tokens[i] as string;
+            let index = lookup[token] || -1;
+            if (index >= 0) {
+                if (reference) { reference.push(index); } else {
+                    reference = [index];
+                    output.push(reference);
+                    pointer++;
+                }
+            } else {
+                reference = null;
+                output.push(token);
+                lookup[token] = pointer++;
+            }
+        } else {
+            // If the value is anything other than string, append it as it is to the output array
+            // And, also increment the pointer to stay in sync with output array
+            reference = null;
+            output.push(tokens[i]);
+            pointer++;
+        }
+    }
+    return output;
+}

package/src/data/upgrade.ts

@@ -1,37 +1,37 @@
-import { Constant, Event, UpgradeData } from "@clarity-types/data";
-import * as core from "@src/core";
-import config from "@src/core/config";
-import encode from "@src/data/encode";
-import * as metadata from "@src/data/metadata";
-
-export let data: UpgradeData = null;
-
-export function start(): void {
-    if (!config.lean && config.upgrade) { config.upgrade(Constant.Config); }
-    data = null;
-}
-
-// Following call will upgrade the session from lean mode into the full mode retroactively from the start of the page.
-// As part of the lean mode, we do not send back any layout information - including discovery of DOM and mutations.
-// However, if there's a need for full fidelity playback, calling this function will disable lean mode
-// and send all backed up layout events to the server.
-export function upgrade(key: string): void {
-    // Upgrade only if Clarity was successfully activated on the page
-    if (core.active() && config.lean) {
-        config.lean = false;
-        data = { key };
-
-        // Update metadata to track we have upgraded this session
-        metadata.callback();
-        metadata.save();
-
-        // Callback upgrade handler, if configured
-        if (config.upgrade) { config.upgrade(key); }
-
-        encode(Event.Upgrade);
-    }
-}
-
-export function stop(): void {
-    data = null;
-}
+import { Constant, Event, UpgradeData } from "@clarity-types/data";
+import * as core from "@src/core";
+import config from "@src/core/config";
+import encode from "@src/data/encode";
+import * as metadata from "@src/data/metadata";
+
+export let data: UpgradeData = null;
+
+export function start(): void {
+    if (!config.lean && config.upgrade) { config.upgrade(Constant.Config); }
+    data = null;
+}
+
+// Following call will upgrade the session from lean mode into the full mode retroactively from the start of the page.
+// As part of the lean mode, we do not send back any layout information - including discovery of DOM and mutations.
+// However, if there's a need for full fidelity playback, calling this function will disable lean mode
+// and send all backed up layout events to the server.
+export function upgrade(key: string): void {
+    // Upgrade only if Clarity was successfully activated on the page
+    if (core.active() && config.lean) {
+        config.lean = false;
+        data = { key };
+
+        // Update metadata to track we have upgraded this session
+        metadata.callback();
+        metadata.save();
+
+        // Callback upgrade handler, if configured
+        if (config.upgrade) { config.upgrade(key); }
+
+        encode(Event.Upgrade);
+    }
+}
+
+export function stop(): void {
+    data = null;
+}