clarity-js 0.8.9 → 0.8.10

package/src/data/consent.ts

@@ -4,7 +4,7 @@ import * as dimension from "@src/data/dimension";
 const enum ConsentType {
     None = 0,
     Implicit = 1,
-    General = 2
+    General = 2,
 }
 
 export function config(track: boolean): void {
@@ -18,4 +18,4 @@ export function consent(): void {
 
 function trackConsent(consent: ConsentType): void {
     dimension.log(Dimension.Consent, consent.toString());
-}
+}

package/src/data/custom.ts

@@ -1,4 +1,4 @@
-import { Constant, CustomData, Event } from "@clarity-types/data";
+import { type CustomData, Event } from "@clarity-types/data";
 import * as core from "@src/core";
 import encode from "./encode";
 
@@ -7,17 +7,12 @@ 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);
-        
+    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);
     }
 }

package/src/data/dimension.ts

@@ -1,4 +1,4 @@
-import { Check, Event, Dimension, DimensionData, Setting } from "@clarity-types/data";
+import { Check, type Dimension, type DimensionData, Event, Setting } from "@clarity-types/data";
 import * as limit from "@src/data/limit";
 import encode from "./encode";
 
@@ -18,18 +18,20 @@ export function stop(): void {
     limited = false;
 }
 
-export function log(dimension: Dimension, value: string): void {
+export function log(dimension: Dimension, inputValue: string): void {
     // Check valid value before moving ahead
-    if (value) {
+    if (inputValue) {
         // 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] = []; }
+        const value = `${inputValue}`;
+        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;
             }
@@ -37,7 +39,9 @@ export function log(dimension: Dimension, value: 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,23 @@
-import { Event, Token } from "@clarity-types/data";
+import { Event, type 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 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 {
-    let t = time();
-    let tokens: Token[] = [t, event]; 
+export default function (event: Event): void {
+    const t = time();
+    let tokens: Token[] = [t, event];
     switch (event) {
-        case Event.Baseline:
-            let b = baseline.state;
+        case Event.Baseline: {
+            const b = baseline.state;
             if (b) {
                 tokens = [b.time, b.event];
                 tokens.push(b.data.visible);
@@ -48,6 +48,7 @@ export default function(event: Event): void {
             }
             baseline.reset();
             break;
+        }
         case Event.Ping:
             tokens.push(ping.data.gap);
             queue(tokens);
@@ -72,10 +73,10 @@ export default function(event: Event): void {
             tokens.push(custom.data.value);
             queue(tokens);
             break;
-        case Event.Variable:
-            let variableKeys = Object.keys(variable.data);
+        case Event.Variable: {
+            const variableKeys = Object.keys(variable.data);
             if (variableKeys.length > 0) {
-                for (let v of variableKeys) {
+                for (const v of variableKeys) {
                     tokens.push(v);
                     tokens.push(variable.data[v]);
                 }
@@ -83,11 +84,12 @@ export default function(event: Event): void {
                 queue(tokens, false);
             }
             break;
-        case Event.Metric:
-            let metricKeys = Object.keys(metric.updates);
+        }
+        case Event.Metric: {
+            const metricKeys = Object.keys(metric.updates);
             if (metricKeys.length > 0) {
-                for (let m of metricKeys) {
-                    let key = parseInt(m, 10);
+                for (const m of metricKeys) {
+                    const key = Number.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.
@@ -97,11 +99,12 @@ export default function(event: Event): void {
                 queue(tokens, false);
             }
             break;
-        case Event.Dimension:
-            let dimensionKeys = Object.keys(dimension.updates);
+        }
+        case Event.Dimension: {
+            const dimensionKeys = Object.keys(dimension.updates);
             if (dimensionKeys.length > 0) {
-                for (let d of dimensionKeys) {
-                    let key = parseInt(d, 10);
+                for (const d of dimensionKeys) {
+                    const key = Number.parseInt(d, 10);
                     tokens.push(key);
                     tokens.push(dimension.updates[d]);
                 }
@@ -109,11 +112,12 @@ export default function(event: Event): void {
                 queue(tokens, false);
             }
             break;
-        case Event.Summary:
-            let eventKeys = Object.keys(summary.data);
+        }
+        case Event.Summary: {
+            const eventKeys = Object.keys(summary.data);
             if (eventKeys.length > 0) {
-                for (let e of eventKeys) {
-                    let key = parseInt(e, 10);
+                for (const e of eventKeys) {
+                    const key = Number.parseInt(e, 10);
                     tokens.push(key);
                     tokens.push([].concat(...summary.data[e]));
                 }
@@ -121,20 +125,22 @@ export default function(event: Event): void {
                 queue(tokens, false);
             }
             break;
-        case Event.Extract:
-            let extractKeys = extract.keys;
-            extractKeys.forEach((e => {
+        }
+        case Event.Extract: {
+            const extractKeys = extract.keys;
+            for (const e of Array.from(extractKeys)) {
                 tokens.push(e);
-                let token = []
-                for (let d in extract.data[e]) {
-                    let key = parseInt(d, 10);
+                const token = [];
+                for (const d in extract.data[e]) {
+                    const key = Number.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,27 +1,27 @@
-import { BooleanFlag, Token, Upload, Envelope, ApplicationPlatform } from "@clarity-types/data";
+import { ApplicationPlatform, BooleanFlag, type Envelope, type Token, Upload } from "@clarity-types/data";
+import * as scrub from "@src/core/scrub";
 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,
+    ];
 }

package/src/data/extract.ts

@@ -1,18 +1,18 @@
-import { ExtractSource, Syntax, Type } from "@clarity-types/core";
-import { Event, Setting, ExtractData } from "@clarity-types/data";
-import encode from "./encode";
-import * as internal from "@src/diagnostic/internal";
+import { ExtractSource, type Syntax, Type } from "@clarity-types/core";
+import { Event, type ExtractData, Setting } from "@clarity-types/data";
 import { Code, Constant, Severity } from "@clarity-types/data";
 import { hashText } from "@src/clarity";
 import hash from "@src/core/hash";
+import * as internal from "@src/diagnostic/internal";
+import encode from "./encode";
 
-export let data: ExtractData = {};
-export let keys: Set<number> = new Set();
+export const data: ExtractData = {};
+export const keys: Set<number> = new Set();
 
-let variables : { [key: number]: { [key: number]: Syntax[] }} = {};
-let selectors : { [key: number]: { [key: number]: string }} = {};
-let hashes : { [key: number]: { [key: number]: string }} = {};
-let validation : { [key: number]: string } = {};
+const variables: { [key: number]: { [key: number]: Syntax[] } } = {};
+const selectors: { [key: number]: { [key: number]: string } } = {};
+const hashes: { [key: number]: { [key: number]: string } } = {};
+const validation: { [key: number]: string } = {};
 
 export function start(): void {
     reset();
@@ -23,44 +23,45 @@ export function start(): void {
 // if element is present on the page it will set up event 101 to grab the contents of the class1 selector into component 1,
 // the javascript evaluated contents of window.a.b into component 2,
 // and the contents of Clarity's hash abc into component 3
-export function trigger(input: string): void { 
+export function trigger(input: string): void {
     try {
-        var parts = input && input.length > 0 ? input.split(/ (.*)/) : [Constant.Empty];
-        var keyparts = parts[0].split(/\|(.*)/);
-        var key = parseInt(keyparts[0]);
-        var element = keyparts.length > 1 ?  keyparts[1] : Constant.Empty;
-        var values = parts.length > 1 ? JSON.parse(parts[1]) : {};
+        const parts = input && input.length > 0 ? input.split(/ (.*)/) : [Constant.Empty];
+        const keyparts = parts[0].split(/\|(.*)/);
+        const key = Number.parseInt(keyparts[0]);
+        const element = keyparts.length > 1 ? keyparts[1] : Constant.Empty;
+        const values = parts.length > 1 ? JSON.parse(parts[1]) : {};
         variables[key] = {};
         selectors[key] = {};
         hashes[key] = {};
         validation[key] = element;
-        for (var v in values) {
-            // values is a set of strings for proper JSON parsing, but it's more efficient 
+        for (const v in values) {
+            // values is a set of strings for proper JSON parsing, but it's more efficient
             // to interact with them as numbers
-            let id = parseInt(v);
-            let value = values[v] as string;
+            const id = Number.parseInt(v);
+            const value = values[v] as string;
             let source = ExtractSource.Text;
             if (value.startsWith(Constant.Tilde)) {
-                source = ExtractSource.Javascript
+                source = ExtractSource.Javascript;
             } else if (value.startsWith(Constant.Bang)) {
-                source = ExtractSource.Hash
+                source = ExtractSource.Hash;
             }
             switch (source) {
-                case ExtractSource.Javascript:
-                    let variable = value.slice(1);
+                case ExtractSource.Javascript: {
+                    const variable = value.slice(1);
                     variables[key][id] = parse(variable);
                     break;
+                }
                 case ExtractSource.Text:
                     selectors[key][id] = value;
                     break;
-                case ExtractSource.Hash:
-                    let hash = value.slice(1);
+                case ExtractSource.Hash: {
+                    const hash = value.slice(1);
                     hashes[key][id] = hash;
                     break;
+                }
             }
         }
-    }
-    catch(e) {
+    } catch (e) {
         internal.log(Code.Config, Severity.Warning, e ? e.name : null);
     }
 }
@@ -71,39 +72,40 @@ export function clone(v: Syntax[]): Syntax[] {
 
 export function compute(): void {
     try {
-        for (let v in variables) {
-            let key = parseInt(v);
-            if (validation[key] == Constant.Empty || document.querySelector(validation[key]))
-            {
-                let variableData = variables[key];
-                for (let v in variableData) {
-                    let variableKey = parseInt(v);
-                    let value = str(evaluate(clone(variableData[variableKey])));
-                    if (value) { 
+        for (const v in variables) {
+            const key = Number.parseInt(v);
+            if (validation[key] === Constant.Empty || document.querySelector(validation[key])) {
+                const variableData = variables[key];
+                for (const v in variableData) {
+                    const variableKey = Number.parseInt(v);
+                    const value = str(evaluate(clone(variableData[variableKey])));
+                    if (value) {
                         update(key, variableKey, value);
                     }
                 }
 
-                let selectorData = selectors[key];
-                for (let s in selectorData) {
+                const selectorData = selectors[key];
+                for (const s in selectorData) {
                     let shouldMask = false;
-                    let selectorKey = parseInt(s);
+                    const selectorKey = Number.parseInt(s);
                     let selector = selectorData[selectorKey];
-                    if (selector.startsWith(Constant.At)){
+                    if (selector.startsWith(Constant.At)) {
                         shouldMask = true;
                         selector = selector.slice(1);
                     }
-                    let nodes = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
+                    const nodes = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
                     if (nodes) {
-                        let text = Array.from(nodes).map(e => e.textContent).join(Constant.Seperator);
+                        const text = Array.from(nodes)
+                            .map((e) => e.textContent)
+                            .join(Constant.Seperator);
                         update(key, selectorKey, (shouldMask ? hash(text).trim() : text).slice(0, Setting.ExtractLimit));
                     }
                 }
 
-                let hashData = hashes[key];
-                for (let h in hashData) {
-                    let hashKey = parseInt(h);
-                    let content = hashText(hashData[hashKey]).trim().slice(0, Setting.ExtractLimit);
+                const hashData = hashes[key];
+                for (const h in hashData) {
+                    const hashKey = Number.parseInt(h);
+                    const content = hashText(hashData[hashKey]).trim().slice(0, Setting.ExtractLimit);
                     update(key, hashKey, content);
                 }
             }
@@ -112,8 +114,9 @@ export function compute(): void {
         if (keys.size > 0) {
             encode(Event.Extract);
         }
+    } catch (e) {
+        internal.log(Code.Selector, Severity.Warning, e ? e.name : null);
     }
-    catch (e) { internal.log(Code.Selector, Severity.Warning, e ? e.name : null); }
 }
 
 export function reset(): void {
@@ -121,15 +124,13 @@ export function reset(): void {
 }
 
 export function update(key: number, subkey: number, value: string): void {
-    var update = false;
+    let update = false;
     if (!(key in data)) {
         data[key] = {};
         update = true;
     }
-    
-    if (!isEmpty(hashes[key]) 
-        && (!(subkey in data[key]) || data[key][subkey] != value))
-    {
+
+    if (!isEmpty(hashes[key]) && (!(subkey in data[key]) || data[key][subkey] !== value)) {
         update = true;
     }
 
@@ -142,21 +143,21 @@ export function update(key: number, subkey: number, value: string): void {
 }
 
 export function stop(): void {
-   reset();
+    reset();
 }
 
 function parse(variable: string): Syntax[] {
-    let syntax: Syntax[] = [];
-    let parts = variable.split(Constant.Dot);
+    const syntax: Syntax[] = [];
+    const parts = variable.split(Constant.Dot);
     while (parts.length > 0) {
-        let part = parts.shift();
-        let arrayStart = part.indexOf(Constant.ArrayStart);
-        let conditionStart = part.indexOf(Constant.ConditionStart);
-        let conditionEnd = part.indexOf(Constant.ConditionEnd);
+        const part = parts.shift();
+        const arrayStart = part.indexOf(Constant.ArrayStart);
+        const conditionStart = part.indexOf(Constant.ConditionStart);
+        const conditionEnd = part.indexOf(Constant.ConditionEnd);
         syntax.push({
-            name : arrayStart > 0 ? part.slice(0, arrayStart) : (conditionStart > 0 ? part.slice(0, conditionStart) : part),
-            type : arrayStart > 0 ? Type.Array : (conditionStart > 0 ? Type.Object : Type.Simple),
-            condition : conditionStart > 0 ? part.slice(conditionStart + 1, conditionEnd) : null
+            name: arrayStart > 0 ? part.slice(0, arrayStart) : conditionStart > 0 ? part.slice(0, conditionStart) : part,
+            type: arrayStart > 0 ? Type.Array : conditionStart > 0 ? Type.Object : Type.Simple,
+            condition: conditionStart > 0 ? part.slice(conditionStart + 1, conditionEnd) : null,
         });
     }
 
@@ -166,26 +167,32 @@ function parse(variable: string): Syntax[] {
 // The function below takes in a variable name in following format: "a.b.c" and safely evaluates its value in javascript context
 // For instance, for a.b.c, it will first check window["a"]. If it exists, it will recursively look at: window["a"]["b"] and finally,
 // return the value for window["a"]["b"]["c"].
+// biome-ignore lint/complexity/noBannedTypes: type of base is intentionally generic
+// biome-ignore lint/suspicious/noExplicitAny: type of return value isn't known
 function evaluate(variable: Syntax[], base: Object = window): any {
-    if (variable.length == 0) { return base; }
-    let part = variable.shift();
+    if (variable.length === 0) {
+        return base;
+    }
+    const part = variable.shift();
+    // biome-ignore lint/suspicious/noImplicitAnyLet: type of return value isn't known
     let output;
-    if (base && base[part.name]) {
-        let obj = base[part.name];
+    if (base?.[part.name]) {
+        const obj = base[part.name];
         if (part.type !== Type.Array && match(obj, part.condition)) {
             output = evaluate(variable, obj);
-        }
-        else if (Array.isArray(obj)) {
-            let filtered = [];
-            for (var value of obj) {
+        } else if (Array.isArray(obj)) {
+            const filtered = [];
+            for (const value of obj) {
                 if (match(value, part.condition)) {
-                    let op = evaluate(variable, value)
-                    if (op) { filtered.push(op); }
+                    const op = evaluate(variable, value);
+                    if (op) {
+                        filtered.push(op);
+                    }
                 }
             }
             output = filtered;
         }
-        
+
         return output;
     }
 
@@ -197,15 +204,17 @@ function str(input: string): string {
     return input ? JSON.stringify(input).slice(0, Setting.ExtractLimit) : input;
 }
 
+// biome-ignore lint/complexity/noBannedTypes: type of base is intentionally generic
 function match(base: Object, condition: string): boolean {
     if (condition) {
-        let prop = condition.split(":");
-        return prop.length > 1 ? base[prop[0]] == prop[1] : base[prop[0]]
+        const prop = condition.split(":");
+        return prop.length > 1 ? base[prop[0]] === prop[1] : base[prop[0]];
     }
 
     return true;
 }
 
+// biome-ignore lint/complexity/noBannedTypes: type of obj is intentionally generic
 function isEmpty(obj: Object): boolean {
-    return Object.keys(obj).length == 0;
+    return Object.keys(obj).length === 0;
 }

package/src/data/index.ts

@@ -1,17 +1,17 @@
+import type { Module } from "@clarity-types/core";
 import measure from "@src/core/measure";
 import * as baseline from "@src/data/baseline";
-import * as envelope from "@src/data/envelope";
 import * as dimension from "@src/data/dimension";
+import * as envelope from "@src/data/envelope";
+import * as extract from "@src/data/extract";
+import * as limit from "@src/data/limit";
 import * as metadata from "@src/data/metadata";
-import { Module } from "@clarity-types/core";
 import * as metric from "@src/data/metric";
 import * as ping from "@src/data/ping";
-import * as limit from "@src/data/limit";
 import * as summary from "@src/data/summary";
 import * as upgrade from "@src/data/upgrade";
 import * as upload from "@src/data/upload";
 import * as variable from "@src/data/variable";
-import * as extract from "@src/data/extract";
 export { event } from "@src/data/custom";
 export { consent, metadata } from "@src/data/metadata";
 export { upgrade } from "@src/data/upgrade";
@@ -23,7 +23,9 @@ const modules: Module[] = [baseline, dimension, variable, limit, summary, metada
 export function start(): void {
     // Metric needs to be initialized before we can start measuring. so metric is not wrapped in measure
     metric.start();
-    modules.forEach(x => measure(x.start)());
+    for (const x of modules) {
+        measure(x.start)();
+    }
 }
 
 export function stop(): void {
@@ -31,7 +33,9 @@ export function stop(): void {
     // The ordering below should respect inter-module dependency.
     // E.g. if upgrade depends on upload, then upgrade needs to end before upload.
     // Similarly, if upload depends on metadata, upload needs to end before metadata.
-    modules.slice().reverse().forEach(x => measure(x.stop)());
+    for (const x of modules.slice().reverse()) {
+        measure(x.stop)();
+    }
     metric.stop();
 }
 

package/src/data/limit.ts

@@ -1,4 +1,4 @@
-import { Check, Event, LimitData, Setting } from "@clarity-types/data";
+import { Check, Event, type LimitData, Setting } from "@clarity-types/data";
 import * as clarity from "@src/clarity";
 import { time } from "@src/core/time";
 import * as envelope from "@src/data/envelope";