clarity-js 0.8.10-beta → 0.8.10

package/src/core/index.ts

@@ -1,13 +1,13 @@
-import { Config } from "@clarity-types/core";
+import type { Config } from "@clarity-types/core";
 import { Constant } from "@clarity-types/data";
 import { FunctionNames } from "@clarity-types/performance";
+import * as clarity from "@src/clarity";
 import configuration from "@src/core/config";
 import * as event from "@src/core/event";
 import * as history from "@src/core/history";
 import * as report from "@src/core/report";
 import * as task from "@src/core/task";
 import * as time from "@src/core/time";
-import * as clarity from "@src/clarity";
 import * as custom from "@src/data/custom";
 
 let status = false;
@@ -36,15 +36,17 @@ export function active(): boolean {
 
 export function check(): boolean {
     try {
-        let globalPrivacyControlSet = navigator && "globalPrivacyControl" in navigator && navigator['globalPrivacyControl'] == true;
-        return status === false &&
+        const globalPrivacyControlSet = navigator && "globalPrivacyControl" in navigator && navigator.globalPrivacyControl === true;
+        return (
+            status === false &&
             typeof Promise !== "undefined" &&
-            window["MutationObserver"] &&
-            document["createTreeWalker"] &&
+            window.MutationObserver &&
+            document.createTreeWalker &&
             "now" in Date &&
             "now" in performance &&
             typeof WeakMap !== "undefined" &&
             !globalPrivacyControlSet
+        );
     } catch (ex) {
         return false;
     }
@@ -52,9 +54,13 @@ export function check(): boolean {
 
 export function config(override: Config): boolean {
     // Process custom configuration overrides, if available
-    if (override === null || status) { return false; }
-    for (let key in override) {
-        if (key in configuration) { configuration[key] = override[key]; }
+    if (override === null || status) {
+        return false;
+    }
+    for (const key in override) {
+        if (key in configuration) {
+            configuration[key] = override[key];
+        }
     }
     return true;
 }
@@ -71,8 +77,12 @@ export function suspend(): void {
     if (status) {
         custom.event(Constant.Clarity, Constant.Suspend);
         clarity.stop();
-        ["mousemove", "touchstart"].forEach(x => event.bind(document, x, restart));
-        ["resize", "scroll", "pageshow"].forEach(x => event.bind(window, x, restart));
+        for (const x of ["mousemove", "touchstart"]) {
+            event.bind(document, x, restart);
+        }
+        for (const x of ["resize", "scroll", "pageshow"]) {
+            event.bind(window, x, restart);
+        }
     }
 }
 

package/src/core/measure.ts

@@ -3,12 +3,16 @@ import { report } from "@src/core/report";
 import * as metric from "@src/data/metric";
 import * as internal from "@src/diagnostic/internal";
 
-// tslint:disable-next-line: ban-types
+// biome-ignore lint/complexity/noBannedTypes: specifically looking to instrument function calls
 export default function (method: Function): Function {
-    return function (): void {
-        let start = performance.now();
-        try { method.apply(this, arguments); } catch (ex) { throw report(ex); }
-        let duration = performance.now() - start;
+    return function (...args): void {
+        const start = performance.now();
+        try {
+            method.apply(this, args);
+        } catch (ex) {
+            throw report(ex);
+        }
+        const duration = performance.now() - start;
         metric.sum(Metric.TotalCost, duration);
         if (duration > Setting.LongTask) {
             metric.count(Metric.LongTaskCount);

package/src/core/report.ts

@@ -1,4 +1,4 @@
-import { Report } from "@clarity-types/core";
+import type { Report } from "@clarity-types/core";
 import config from "@src/core/config";
 import { data } from "@src/data/envelope";
 
@@ -13,12 +13,16 @@ export function report(e: Error): Error {
     if (history && history.indexOf(e.message) === -1) {
         const url = config.report;
         if (url && url.length > 0) {
-            let payload: Report = {v: data.version, p: data.projectId, u: data.userId, s: data.sessionId, n: data.pageNum};
-            if (e.message) { payload.m = e.message; }
-            if (e.stack) { payload.e = e.stack; }
+            const payload: Report = { v: data.version, p: data.projectId, u: data.userId, s: data.sessionId, n: data.pageNum };
+            if (e.message) {
+                payload.m = e.message;
+            }
+            if (e.stack) {
+                payload.e = e.stack;
+            }
             // Using POST request instead of a GET request (img-src) to not violate existing CSP rules
             // Since, Clarity already uses XHR to upload data, we stick with similar POST mechanism for reporting too
-            let xhr = new XMLHttpRequest();
+            const xhr = new XMLHttpRequest();
             xhr.open("POST", url, true);
             xhr.send(JSON.stringify(payload));
             history.push(e.message);

package/src/core/scrub.ts

@@ -10,9 +10,9 @@ let digitRegex = null;
 let letterRegex = null;
 let currencyRegex = null;
 
-export function text(value: string, hint: string, privacy: Privacy, mangle: boolean = false, type?: string): string {
+export function text(value: string, hint: string, privacy: Privacy, mangle = false, type?: string): string {
     if (value) {
-        if (hint == "input" && (type === "checkbox" || type === "radio")) {
+        if (hint === "input" && (type === "checkbox" || type === "radio")) {
             return value;
         }
 
@@ -88,17 +88,21 @@ export function text(value: string, hint: string, privacy: Privacy, mangle: bool
     return value;
 }
 
-export function url(input: string, electron: boolean = false, truncate: boolean = false): string {
+export function url(input: string, electron = false, truncate = false): string {
     let result = input;
     // Replace the URL for Electron apps so we don't send back file:/// URL
     if (electron) {
         result = `${Data.Constant.HTTPS}${Data.Constant.Electron}`;
     } else {
-        let drop = config.drop;
+        const drop = config.drop;
         if (drop && drop.length > 0 && input && input.indexOf("?") > 0) {
-            let [path, query] = input.split("?");
-            let swap = Data.Constant.Dropped;
-            result = path + "?" + query.split("&").map(p => drop.some(x => p.indexOf(`${x}=`) === 0) ? `${p.split("=")[0]}=${swap}` : p).join("&");
+            const [path, query] = input.split("?");
+            const swap = Data.Constant.Dropped;
+            result =
+                `${path}?${query
+                    .split("&")
+                    .map((p) => (drop.some((x) => p.indexOf(`${x}=`) === 0) ? `${p.split("=")[0]}=${swap}` : p))
+                    .join("&")}`;
         }
     }
 
@@ -109,12 +113,12 @@ export function url(input: string, electron: boolean = false, truncate: boolean
 }
 
 function mangleText(value: string): string {
-    let trimmed = value.trim();
+    const trimmed = value.trim();
     if (trimmed.length > 0) {
-        let first = trimmed[0];
-        let index = value.indexOf(first);
-        let prefix = value.substr(0, index);
-        let suffix = value.substr(index + trimmed.length);
+        const first = trimmed[0];
+        const index = value.indexOf(first);
+        const prefix = value.substr(0, index);
+        const suffix = value.substr(index + trimmed.length);
         return `${prefix}${trimmed.length.toString(36)}${suffix}`;
     }
     return value;
@@ -130,7 +134,7 @@ export function scrub(value: string, letter: string, digit: string): string {
 }
 
 function mangleToken(value: string): string {
-    let length = ((Math.floor(value.length / Data.Setting.WordLength) + 1) * Data.Setting.WordLength);
+    const length = (Math.floor(value.length / Data.Setting.WordLength) + 1) * Data.Setting.WordLength;
     let output: string = Layout.Constant.Empty;
     for (let i = 0; i < length; i++) {
         output += i > 0 && i % Data.Setting.WordLength === 0 ? Data.Constant.Space : Data.Constant.Mask;
@@ -143,10 +147,12 @@ function regex(): void {
     // Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
     if (unicodeRegex && digitRegex === null) {
         try {
-            digitRegex = new RegExp("\\p{N}", "gu");
-            letterRegex = new RegExp("\\p{L}", "gu");
-            currencyRegex = new RegExp("\\p{Sc}", "gu");
-        } catch { unicodeRegex = false; }
+            digitRegex = /\p{N}/gu;
+            letterRegex = /\p{L}/gu;
+            currencyRegex = /\p{Sc}/gu;
+        } catch {
+            unicodeRegex = false;
+        }
     }
 }
 
@@ -161,16 +167,19 @@ function redact(value: string): string {
     regex(); // Initialize regular expressions
 
     for (let i = 0; i < value.length; i++) {
-        let c = value.charCodeAt(i);
+        const c = value.charCodeAt(i);
         hasDigit = hasDigit || (c >= Data.Character.Zero && c <= Data.Character.Nine); // Check for digits in the current word
         hasEmail = hasEmail || c === Data.Character.At; // Check for @ sign anywhere within the current word
-        hasWhitespace = c === Data.Character.Tab || c === Data.Character.NewLine || c === Data.Character.Return || c === Data.Character.Blank;
+        hasWhitespace =
+            c === Data.Character.Tab || c === Data.Character.NewLine || c === Data.Character.Return || c === Data.Character.Blank;
 
         // Process each word as an individual token to redact any sensitive information
         if (i === 0 || i === value.length - 1 || hasWhitespace) {
             // Performance optimization: Lazy load string -> array conversion only when required
             if (hasDigit || hasEmail) {
-                if (array === null) { array = value.split(Data.Constant.Empty); }
+                if (array === null) {
+                    array = value.split(Data.Constant.Empty);
+                }
                 // Work on a token at a time so we don't have to apply regex to a larger string
                 let token = value.substring(spaceIndex + 1, hasWhitespace ? i : i + 1);
                 // Check if unicode regex is supported, otherwise fallback to calling mask function on this token

package/src/core/task.ts

@@ -1,5 +1,12 @@
-import { AsyncTask, Priority, RequestIdleCallbackDeadline, RequestIdleCallbackOptions, Task, Timer } from "@clarity-types/core";
-import { TaskFunction, TaskResolve, Tasks } from "@clarity-types/core";
+import {
+    type AsyncTask,
+    Priority,
+    type RequestIdleCallbackDeadline,
+    type RequestIdleCallbackOptions,
+    Task,
+    type Timer,
+} from "@clarity-types/core";
+import type { TaskFunction, TaskResolve, Tasks } from "@clarity-types/core";
 import { Code, Metric, Setting, Severity } from "@clarity-types/data";
 import * as metadata from "@src/data/metadata";
 import * as metric from "@src/data/metric";
@@ -25,7 +32,9 @@ export function resume(): void {
     if (pauseTask) {
         resumeResolve();
         pauseTask = null;
-        if (activeTask === null) { run(); }
+        if (activeTask === null) {
+            run();
+        }
     }
 }
 
@@ -38,14 +47,14 @@ export function reset(): void {
 
 export async function schedule(task: TaskFunction, priority: Priority = Priority.Normal): Promise<void> {
     // If this task is already scheduled, skip it
-    for (let q of queuedTasks) {
+    for (const q of queuedTasks) {
         if (q.task === task) {
             return;
         }
     }
 
-    let promise = new Promise<void>((resolve: TaskResolve): void => {
-        let insert = priority === Priority.High ? "unshift" : "push";
+    const promise = new Promise<void>((resolve: TaskResolve): void => {
+        const insert = priority === Priority.High ? "unshift" : "push";
         // Queue this task for asynchronous execution later
         // We also store a unique page identifier (id) along with the task to ensure
         // ensure that we do not accidentally execute this task in context of a different page
@@ -54,38 +63,49 @@ export async function schedule(task: TaskFunction, priority: Priority = Priority
 
     // If there is no active task running, and Clarity is not in pause state,
     // invoke the first task in the queue synchronously. This ensures that we don't yield the thread during unload event
-    if (activeTask === null && pauseTask === null) { run(); }
+    if (activeTask === null && pauseTask === null) {
+        run();
+    }
 
     return promise;
 }
 
 function run(): void {
-    let entry = queuedTasks.shift();
+    const entry = queuedTasks.shift();
     if (entry) {
         activeTask = entry;
-        entry.task().then((): void => {
-            // Bail out if the context in which this task was operating is different from the current page
-            // An example scenario where task could span across pages is Single Page Applications (SPA)
-            // A task that started on page #1, but completes on page #2
-            if (entry.id !== metadata.id()) { return; }
-            entry.resolve();
-            activeTask = null; // Reset active task back to null now that the promise is resolved
-            run();
-        }).catch((error: Error): void => {
-            // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
-            if (entry.id !== metadata.id()) { return; }
-            if (error) { internal.log(Code.RunTask, Severity.Warning, error.name, error.message, error.stack); }
-            activeTask = null;
-            run();
-        });
+        entry
+            .task()
+            .then((): void => {
+                // Bail out if the context in which this task was operating is different from the current page
+                // An example scenario where task could span across pages is Single Page Applications (SPA)
+                // A task that started on page #1, but completes on page #2
+                if (entry.id !== metadata.id()) {
+                    return;
+                }
+                entry.resolve();
+                activeTask = null; // Reset active task back to null now that the promise is resolved
+                run();
+            })
+            .catch((error: Error): void => {
+                // If one of the scheduled tasks failed, log, recover and continue processing rest of the tasks
+                if (entry.id !== metadata.id()) {
+                    return;
+                }
+                if (error) {
+                    internal.log(Code.RunTask, Severity.Warning, error.name, error.message, error.stack);
+                }
+                activeTask = null;
+                run();
+            });
     }
 }
 
 export function state(timer: Timer): Task {
-    let id = key(timer);
+    const id = key(timer);
     if (id in tracker) {
-        let elapsed = performance.now() - tracker[id].start;
-        return (elapsed > tracker[id].yield) ? Task.Wait : Task.Run;
+        const elapsed = performance.now() - tracker[id].start;
+        return elapsed > tracker[id].yield ? Task.Wait : Task.Run;
     }
     // If this task is no longer being tracked, send stop message to the caller
     return Task.Stop;
@@ -96,10 +116,10 @@ export function start(timer: Timer): void {
 }
 
 function restart(timer: Timer): void {
-    let id = key(timer);
-    if (tracker && tracker[id]) {
-        let c = tracker[id].calls;
-        let y = tracker[id].yield;
+    const id = key(timer);
+    if (tracker?.[id]) {
+        const c = tracker[id].calls;
+        const y = tracker[id].yield;
         start(timer);
         tracker[id].calls = c + 1;
         tracker[id].yield = y;
@@ -107,15 +127,17 @@ function restart(timer: Timer): void {
 }
 
 export function stop(timer: Timer): void {
-    let end = performance.now();
-    let id = key(timer);
-    let duration = end - tracker[id].start;
+    const end = performance.now();
+    const id = key(timer);
+    const duration = end - tracker[id].start;
     metric.sum(timer.cost, duration);
     metric.count(Metric.InvokeCount);
 
     // For the first execution, which is synchronous, time is automatically counted towards TotalDuration.
     // However, for subsequent asynchronous runs, we need to manually update TotalDuration metric.
-    if (tracker[id].calls > 0) { metric.sum(Metric.TotalCost, duration); }
+    if (tracker[id].calls > 0) {
+        metric.sum(Metric.TotalCost, duration);
+    }
 }
 
 export async function suspend(timer: Timer): Promise<Task> {
@@ -123,10 +145,10 @@ export async function suspend(timer: Timer): Promise<Task> {
     // It's possible that Clarity is wrapping up instrumentation on a page and we are still in the middle of an async task.
     // In that case, we do not wish to continue yielding thread.
     // Instead, we will turn async task into a sync task and maximize our chances of getting some data back.
-    let id = key(timer);
+    const id = key(timer);
     if (id in tracker) {
         stop(timer);
-        // some customer polyfills for requestIdleCallback return null 
+        // some customer polyfills for requestIdleCallback return null
         tracker[id].yield = (await wait())?.timeRemaining() || Setting.LongTask;
         restart(timer);
     }
@@ -140,7 +162,9 @@ function key(timer: Timer): string {
 }
 
 async function wait(): Promise<RequestIdleCallbackDeadline> {
-    if (pauseTask) { await pauseTask; }
+    if (pauseTask) {
+        await pauseTask;
+    }
     return new Promise<RequestIdleCallbackDeadline>((resolve: (deadline: RequestIdleCallbackDeadline) => void): void => {
         requestIdleCallback(resolve, { timeout: idleTimeout });
     });
@@ -162,20 +186,24 @@ function requestIdleCallbackPolyfill(callback: (deadline: RequestIdleCallbackDea
     const incoming = channel.port1;
     const outgoing = channel.port2;
     incoming.onmessage = (event: MessageEvent): void => {
-        let currentTime = performance.now();
-        let elapsed = currentTime - startTime;
-        let duration = currentTime - event.data;
+        const currentTime = performance.now();
+        const elapsed = currentTime - startTime;
+        const duration = currentTime - event.data;
         if (duration > Setting.LongTask && elapsed < options.timeout) {
-            requestAnimationFrame((): void => { outgoing.postMessage(currentTime); });
+            requestAnimationFrame((): void => {
+                outgoing.postMessage(currentTime);
+            });
         } else {
-            let didTimeout = elapsed > options.timeout;
+            const didTimeout = elapsed > options.timeout;
             callback({
                 didTimeout,
-                timeRemaining: (): number => didTimeout ? Setting.LongTask : Math.max(0, Setting.LongTask - duration)
+                timeRemaining: (): number => (didTimeout ? Setting.LongTask : Math.max(0, Setting.LongTask - duration)),
             });
         }
     };
-    requestAnimationFrame((): void => { outgoing.postMessage(performance.now()); });
+    requestAnimationFrame((): void => {
+        outgoing.postMessage(performance.now());
+    });
 }
 
-let requestIdleCallback = window["requestIdleCallback"] || requestIdleCallbackPolyfill;
+const requestIdleCallback = window.requestIdleCallback || requestIdleCallbackPolyfill;

package/src/core/time.ts

@@ -4,13 +4,13 @@ export function start(): void {
     startTime = performance.now() + performance.timeOrigin;
 }
 
-// event.timestamp is number of milliseconds elapsed since the document was loaded 
+// event.timestamp is number of milliseconds elapsed since the document was loaded
 // since iframes can be loaded later the event timestamp is not the same as performance.now()
 // converting everything to absolute time by adding timeorigin of the event view
 // to synchronize times before calculating the difference with start time
 export function time(event: UIEvent | PageTransitionEvent = null): number {
-    let ts = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
-    let origin = event && (event as UIEvent).view ? (event as UIEvent).view.performance.timeOrigin : performance.timeOrigin;
+    const ts = event && event.timeStamp > 0 ? event.timeStamp : performance.now();
+    const origin = event && (event as UIEvent).view ? (event as UIEvent).view.performance.timeOrigin : performance.timeOrigin;
     return Math.max(Math.round(ts + origin - startTime), 0);
 }
 

package/src/core/timeout.ts

@@ -1,4 +1,4 @@
-import { Event } from "@clarity-types/data";
+import type { Event } from "@clarity-types/data";
 import measure from "./measure";
 
 export function setTimeout(handler: (event?: Event | boolean) => void, timeout?: number, event?: Event): number {
@@ -6,5 +6,5 @@ export function setTimeout(handler: (event?: Event | boolean) => void, timeout?:
 }
 
 export function clearTimeout(handle: number): void {
-    return window.clearTimeout(handle);
+    window.clearTimeout(handle);
 }

package/src/core/version.ts

@@ -1,2 +1,2 @@
-let version = "0.8.10-beta";
+const version = "0.8.10";
 export default version;

package/src/data/baseline.ts

@@ -1,11 +1,11 @@
-import { Event, BooleanFlag } from "@clarity-types/data";
-import { BaselineData, BaselineState } from "@clarity-types/data";
+import { BooleanFlag, Event } from "@clarity-types/data";
+import type { BaselineData, BaselineState } from "@clarity-types/data";
 import { time } from "@src/core/time";
 import encode from "@src/data/encode";
 
 export let state: BaselineState = null;
 let buffer: BaselineData = null;
-let update: boolean = false;
+let update = false;
 
 export function start(): void {
     update = false;
@@ -16,60 +16,65 @@ export function reset(): void {
     // Baseline state holds the previous values - if it is updated in the current payload,
     // reset the state to current value after sending the previous state
     if (update) {
-        state = { time: time(), event: Event.Baseline, data: {
-            visible: buffer.visible,
-            docWidth: buffer.docWidth,
-            docHeight: buffer.docHeight,
-            screenWidth: buffer.screenWidth,
-            screenHeight: buffer.screenHeight,
-            scrollX: buffer.scrollX,
-            scrollY: buffer.scrollY,
-            pointerX: buffer.pointerX,
-            pointerY: buffer.pointerY,
-            activityTime: buffer.activityTime,
-            scrollTime: buffer.scrollTime,
-            pointerTime: buffer.pointerTime,
-            moveX: buffer.moveX,
-            moveY: buffer.moveY,
-            moveTime: buffer.moveTime,
-            downX: buffer.downX,
-            downY: buffer.downY,
-            downTime: buffer.downTime,
-            upX: buffer.upX,
-            upY: buffer.upY,
-            upTime: buffer.upTime,
-            pointerPrevX: buffer.pointerPrevX,
-            pointerPrevY: buffer.pointerPrevY,
-            pointerPrevTime: buffer.pointerPrevTime,
-          }
+        state = {
+            time: time(),
+            event: Event.Baseline,
+            data: {
+                visible: buffer.visible,
+                docWidth: buffer.docWidth,
+                docHeight: buffer.docHeight,
+                screenWidth: buffer.screenWidth,
+                screenHeight: buffer.screenHeight,
+                scrollX: buffer.scrollX,
+                scrollY: buffer.scrollY,
+                pointerX: buffer.pointerX,
+                pointerY: buffer.pointerY,
+                activityTime: buffer.activityTime,
+                scrollTime: buffer.scrollTime,
+                pointerTime: buffer.pointerTime,
+                moveX: buffer.moveX,
+                moveY: buffer.moveY,
+                moveTime: buffer.moveTime,
+                downX: buffer.downX,
+                downY: buffer.downY,
+                downTime: buffer.downTime,
+                upX: buffer.upX,
+                upY: buffer.upY,
+                upTime: buffer.upTime,
+                pointerPrevX: buffer.pointerPrevX,
+                pointerPrevY: buffer.pointerPrevY,
+                pointerPrevTime: buffer.pointerPrevTime,
+            },
         };
     }
-    buffer = buffer ? buffer : {
-        visible: BooleanFlag.True,
-        docWidth: 0,
-        docHeight: 0,
-        screenWidth: 0,
-        screenHeight: 0,
-        scrollX: 0,
-        scrollY: 0,
-        pointerX: 0,
-        pointerY: 0,
-        activityTime: 0,
-        scrollTime: 0,
-        pointerTime: undefined,
-        moveX: undefined,
-        moveY: undefined,
-        moveTime: undefined,
-        downX: undefined,
-        downY: undefined,
-        downTime: undefined,
-        upX: undefined,
-        upY: undefined,
-        upTime: undefined,
-        pointerPrevX: undefined,
-        pointerPrevY: undefined,
-        pointerPrevTime: undefined,
-    };
+    buffer = buffer
+        ? buffer
+        : {
+              visible: BooleanFlag.True,
+              docWidth: 0,
+              docHeight: 0,
+              screenWidth: 0,
+              screenHeight: 0,
+              scrollX: 0,
+              scrollY: 0,
+              pointerX: 0,
+              pointerY: 0,
+              activityTime: 0,
+              scrollTime: 0,
+              pointerTime: undefined,
+              moveX: undefined,
+              moveY: undefined,
+              moveTime: undefined,
+              downX: undefined,
+              downY: undefined,
+              downTime: undefined,
+              upX: undefined,
+              upY: undefined,
+              upTime: undefined,
+              pointerPrevX: undefined,
+              pointerPrevY: undefined,
+              pointerPrevTime: undefined,
+          };
 }
 
 export function track(event: Event, x: number, y: number, time?: number): void {

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);
     }
 }