clarity-js 0.8.11 → 0.8.13-beta

package/src/data/extract.ts

@@ -1,18 +1,18 @@
-import { ExtractSource, type Syntax, Type } from "@clarity-types/core";
-import { Event, type ExtractData, Setting } from "@clarity-types/data";
+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 { 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 const data: ExtractData = {};
-export const keys: Set<number> = new Set();
+export let data: ExtractData = {};
+export let keys: Set<number> = new Set();
 
-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 } = {};
+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 } = {};
 
 export function start(): void {
     reset();
@@ -23,45 +23,44 @@ 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 {
-        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]) : {};
+        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]) : {};
         variables[key] = {};
         selectors[key] = {};
         hashes[key] = {};
         validation[key] = element;
-        for (const v in values) {
-            // values is a set of strings for proper JSON parsing, but it's more efficient
+        for (var v in values) {
+            // values is a set of strings for proper JSON parsing, but it's more efficient 
             // to interact with them as numbers
-            const id = Number.parseInt(v);
-            const value = values[v] as string;
+            let id = parseInt(v);
+            let 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: {
-                    const variable = value.slice(1);
+                case ExtractSource.Javascript:
+                    let variable = value.slice(1);
                     variables[key][id] = parse(variable);
                     break;
-                }
                 case ExtractSource.Text:
                     selectors[key][id] = value;
                     break;
-                case ExtractSource.Hash: {
-                    const hash = value.slice(1);
+                case ExtractSource.Hash:
+                    let hash = value.slice(1);
                     hashes[key][id] = hash;
                     break;
-                }
             }
         }
-    } catch (e) {
+    }
+    catch(e) {
         internal.log(Code.Config, Severity.Warning, e ? e.name : null);
     }
 }
@@ -72,40 +71,39 @@ export function clone(v: Syntax[]): Syntax[] {
 
 export function compute(): void {
     try {
-        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) {
+        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) { 
                         update(key, variableKey, value);
                     }
                 }
 
-                const selectorData = selectors[key];
-                for (const s in selectorData) {
+                let selectorData = selectors[key];
+                for (let s in selectorData) {
                     let shouldMask = false;
-                    const selectorKey = Number.parseInt(s);
+                    let selectorKey = parseInt(s);
                     let selector = selectorData[selectorKey];
-                    if (selector.startsWith(Constant.At)) {
+                    if (selector.startsWith(Constant.At)){
                         shouldMask = true;
                         selector = selector.slice(1);
                     }
-                    const nodes = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
+                    let nodes = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
                     if (nodes) {
-                        const text = Array.from(nodes)
-                            .map((e) => e.textContent)
-                            .join(Constant.Seperator);
+                        let text = Array.from(nodes).map(e => e.textContent).join(Constant.Seperator);
                         update(key, selectorKey, (shouldMask ? hash(text).trim() : text).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);
+                let hashData = hashes[key];
+                for (let h in hashData) {
+                    let hashKey = parseInt(h);
+                    let content = hashText(hashData[hashKey]).trim().slice(0, Setting.ExtractLimit);
                     update(key, hashKey, content);
                 }
             }
@@ -114,9 +112,8 @@ 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 {
@@ -124,13 +121,15 @@ export function reset(): void {
 }
 
 export function update(key: number, subkey: number, value: string): void {
-    let update = false;
+    var 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;
     }
 
@@ -143,21 +142,21 @@ export function update(key: number, subkey: number, value: string): void {
 }
 
 export function stop(): void {
-    reset();
+   reset();
 }
 
 function parse(variable: string): Syntax[] {
-    const syntax: Syntax[] = [];
-    const parts = variable.split(Constant.Dot);
+    let syntax: Syntax[] = [];
+    let parts = variable.split(Constant.Dot);
     while (parts.length > 0) {
-        const part = parts.shift();
-        const arrayStart = part.indexOf(Constant.ArrayStart);
-        const conditionStart = part.indexOf(Constant.ConditionStart);
-        const conditionEnd = part.indexOf(Constant.ConditionEnd);
+        let part = parts.shift();
+        let arrayStart = part.indexOf(Constant.ArrayStart);
+        let conditionStart = part.indexOf(Constant.ConditionStart);
+        let 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
         });
     }
 
@@ -167,32 +166,26 @@ 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;
-    }
-    const part = variable.shift();
-    // biome-ignore lint/suspicious/noImplicitAnyLet: type of return value isn't known
+    if (variable.length == 0) { return base; }
+    let part = variable.shift();
     let output;
-    if (base?.[part.name]) {
-        const obj = base[part.name];
+    if (base && base[part.name]) {
+        let obj = base[part.name];
         if (part.type !== Type.Array && match(obj, part.condition)) {
             output = evaluate(variable, obj);
-        } else if (Array.isArray(obj)) {
-            const filtered = [];
-            for (const value of obj) {
+        }
+        else if (Array.isArray(obj)) {
+            let filtered = [];
+            for (var value of obj) {
                 if (match(value, part.condition)) {
-                    const op = evaluate(variable, value);
-                    if (op) {
-                        filtered.push(op);
-                    }
+                    let op = evaluate(variable, value)
+                    if (op) { filtered.push(op); }
                 }
             }
             output = filtered;
         }
-
+        
         return output;
     }
 
@@ -204,17 +197,15 @@ 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) {
-        const prop = condition.split(":");
-        return prop.length > 1 ? base[prop[0]] === prop[1] : base[prop[0]];
+        let 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 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 dimension from "@src/data/dimension";
 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,9 +23,7 @@ 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();
-    for (const x of modules) {
-        measure(x.start)();
-    }
+    modules.forEach(x => measure(x.start)());
 }
 
 export function stop(): void {
@@ -33,9 +31,7 @@ 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.
-    for (const x of modules.slice().reverse()) {
-        measure(x.stop)();
-    }
+    modules.slice().reverse().forEach(x => measure(x.stop)());
     metric.stop();
 }
 

package/src/data/limit.ts

@@ -1,4 +1,4 @@
-import { Check, Event, type LimitData, Setting } from "@clarity-types/data";
+import { Check, Event, 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";