clarity-js 0.8.11-beta → 0.8.12

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";