clarity-js 0.8.41 → 0.8.42

package/src/data/variable.ts

@@ -1,84 +1,84 @@
-import { Constant, Event, IdentityData, Setting, VariableData } from "@clarity-types/data";
-import * as core from "@src/core";
-import { scrub } from "@src/core/scrub";
-import encode from "./encode";
-
-export let data: VariableData = null;
-
-export function start(): void {
-    reset();
-}
-
-export function set(variable: string, value: string | string[]): void {
-    let values = typeof value === Constant.String ? [value as string] : value as string[];
-    log(variable, values);
-}
-
-export async function identify(userId: string, sessionId: string = null, pageId: string = null, userHint: string = null): Promise<IdentityData> {
-    let output: IdentityData = { userId: await sha256(userId), userHint: userHint || redact(userId) };
-
-    // By default, hash custom userId using SHA256 algorithm on the client to preserve privacy
-    log(Constant.UserId, [output.userId]);
-    
-    // Optional non-identifying name for the user
-    // If name is not explicitly provided, we automatically generate a redacted version of the userId
-    log(Constant.UserHint, [output.userHint]);
-    log(Constant.UserType, [detect(userId)]);    
-
-    // Log sessionId and pageId if provided
-    if (sessionId) { 
-        log(Constant.SessionId, [sessionId]);
-        output.sessionId = sessionId;
-    }
-    if (pageId) {
-        log(Constant.PageId, [pageId]);
-        output.pageId = pageId;
-    }
-
-    return output;
-}
-
-function log(variable: string, value: string[]): void {
-    if (core.active() &&
-        variable &&
-        value &&
-        typeof variable === Constant.String &&
-        variable.length < 255) {
-        let validValues = variable in data ? data[variable] : [];
-        for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] === Constant.String && value[i].length < 255) { validValues.push(value[i]); }
-        }
-        data[variable] = validValues;
-    }
-}
-
-export function compute(): void {
-    encode(Event.Variable);
-}
-
-export function reset(): void {
-    data = {};
-}
-
-export function stop(): void {
-    reset();
-}
-
-function redact(input: string): string {
-    return input && input.length >= Setting.WordLength ? 
-        `${input.substring(0,2)}${scrub(input.substring(2), Constant.Asterix, Constant.Asterix)}` : scrub(input, Constant.Asterix, Constant.Asterix);
-}
-
-async function sha256(input: string): Promise<string> {
-    try {
-        if (crypto && input) {
-            // Reference: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#converting_a_digest_to_a_hex_string
-            const buffer = await crypto.subtle.digest(Constant.SHA256, new TextEncoder().encode(input));
-            return Array.prototype.map.call(new Uint8Array(buffer), (x: any) =>(('00'+x.toString(16)).slice(-2))).join('');
-        } else { return Constant.Empty; }
-    } catch { return Constant.Empty; }
-}
-
-function detect(input: string): string {
-    return input && input.indexOf(Constant.At) > 0 ? Constant.Email : Constant.String;
+import { Constant, Event, IdentityData, Setting, VariableData } from "@clarity-types/data";
+import * as core from "@src/core";
+import { scrub } from "@src/core/scrub";
+import encode from "./encode";
+
+export let data: VariableData = null;
+
+export function start(): void {
+    reset();
+}
+
+export function set(variable: string, value: string | string[]): void {
+    let values = typeof value === Constant.String ? [value as string] : value as string[];
+    log(variable, values);
+}
+
+export async function identify(userId: string, sessionId: string = null, pageId: string = null, userHint: string = null): Promise<IdentityData> {
+    let output: IdentityData = { userId: await sha256(userId), userHint: userHint || redact(userId) };
+
+    // By default, hash custom userId using SHA256 algorithm on the client to preserve privacy
+    log(Constant.UserId, [output.userId]);
+    
+    // Optional non-identifying name for the user
+    // If name is not explicitly provided, we automatically generate a redacted version of the userId
+    log(Constant.UserHint, [output.userHint]);
+    log(Constant.UserType, [detect(userId)]);    
+
+    // Log sessionId and pageId if provided
+    if (sessionId) { 
+        log(Constant.SessionId, [sessionId]);
+        output.sessionId = sessionId;
+    }
+    if (pageId) {
+        log(Constant.PageId, [pageId]);
+        output.pageId = pageId;
+    }
+
+    return output;
+}
+
+function log(variable: string, value: string[]): void {
+    if (core.active() &&
+        variable &&
+        value &&
+        typeof variable === Constant.String &&
+        variable.length < 255) {
+        let validValues = variable in data ? data[variable] : [];
+        for (let i = 0; i < value.length; i++) {
+            if (typeof value[i] === Constant.String && value[i].length < 255) { validValues.push(value[i]); }
+        }
+        data[variable] = validValues;
+    }
+}
+
+export function compute(): void {
+    encode(Event.Variable);
+}
+
+export function reset(): void {
+    data = {};
+}
+
+export function stop(): void {
+    reset();
+}
+
+function redact(input: string): string {
+    return input && input.length >= Setting.WordLength ? 
+        `${input.substring(0,2)}${scrub(input.substring(2), Constant.Asterix, Constant.Asterix)}` : scrub(input, Constant.Asterix, Constant.Asterix);
+}
+
+async function sha256(input: string): Promise<string> {
+    try {
+        if (crypto && input) {
+            // Reference: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#converting_a_digest_to_a_hex_string
+            const buffer = await crypto.subtle.digest(Constant.SHA256, new TextEncoder().encode(input));
+            return Array.prototype.map.call(new Uint8Array(buffer), (x: any) =>(('00'+x.toString(16)).slice(-2))).join('');
+        } else { return Constant.Empty; }
+    } catch { return Constant.Empty; }
+}
+
+function detect(input: string): string {
+    return input && input.indexOf(Constant.At) > 0 ? Constant.Email : Constant.String;
 }

package/src/diagnostic/encode.ts

@@ -1,40 +1,40 @@
-import { Event, Token } from "@clarity-types/data";
-import * as scrub from "@src/core/scrub";
-import { time } from "@src/core/time";
-import { queue } from "@src/data/upload";
-import * as fraud from "@src/diagnostic/fraud";
-import * as internal from "@src/diagnostic/internal";
-import * as script from "@src/diagnostic/script";
-
-export default async function (type: Event): Promise<void> {
-    let tokens: Token[] = [time(), type];
-
-    switch (type) {
-        case Event.ScriptError:
-            tokens.push(script.data.message);
-            tokens.push(script.data.line);
-            tokens.push(script.data.column);
-            tokens.push(script.data.stack);
-            tokens.push(scrub.url(script.data.source));
-            queue(tokens);
-            break;
-        case Event.Log:
-            if (internal.data) {
-                tokens.push(internal.data.code);
-                tokens.push(internal.data.name);
-                tokens.push(internal.data.message);
-                tokens.push(internal.data.stack);
-                tokens.push(internal.data.severity);
-                queue(tokens, false);
-            }
-            break;
-        case Event.Fraud:
-            if (fraud.data) {
-                tokens.push(fraud.data.id);
-                tokens.push(fraud.data.target);
-                tokens.push(fraud.data.checksum);
-                queue(tokens, false);
-            }
-            break;
-    }
-}
+import { Event, Token } from "@clarity-types/data";
+import * as scrub from "@src/core/scrub";
+import { time } from "@src/core/time";
+import { queue } from "@src/data/upload";
+import * as fraud from "@src/diagnostic/fraud";
+import * as internal from "@src/diagnostic/internal";
+import * as script from "@src/diagnostic/script";
+
+export default async function (type: Event): Promise<void> {
+    let tokens: Token[] = [time(), type];
+
+    switch (type) {
+        case Event.ScriptError:
+            tokens.push(script.data.message);
+            tokens.push(script.data.line);
+            tokens.push(script.data.column);
+            tokens.push(script.data.stack);
+            tokens.push(scrub.url(script.data.source));
+            queue(tokens);
+            break;
+        case Event.Log:
+            if (internal.data) {
+                tokens.push(internal.data.code);
+                tokens.push(internal.data.name);
+                tokens.push(internal.data.message);
+                tokens.push(internal.data.stack);
+                tokens.push(internal.data.severity);
+                queue(tokens, false);
+            }
+            break;
+        case Event.Fraud:
+            if (fraud.data) {
+                tokens.push(fraud.data.id);
+                tokens.push(fraud.data.target);
+                tokens.push(fraud.data.checksum);
+                queue(tokens, false);
+            }
+            break;
+    }
+}

package/src/diagnostic/fraud.ts

@@ -1,37 +1,37 @@
-import { BooleanFlag, Event, IframeStatus, Metric, Setting } from "@clarity-types/data";
-import { FraudData } from "@clarity-types/diagnostic";
-import config from "@src/core/config";
-import hash from "@src/core/hash";
-import * as metric from "@src/data/metric";
-import encode from "./encode";
-
-let history = [];
-export let data: FraudData;
-
-export function start(): void {
-    history = [];
-    metric.max(Metric.Automation, navigator.webdriver ? BooleanFlag.True : BooleanFlag.False);
-    try {
-        // some sites (unintentionally) overwrite the window.self property, so we also check for the main window object
-        metric.max(Metric.Iframed, window.top == window.self || window.top == window ? IframeStatus.TopFrame : IframeStatus.Iframe);
-    } catch (ex) {
-        metric.max(Metric.Iframed, IframeStatus.Unknown);
-    }
-    
-}
-
-export function check(id: number, target: number, input: string): void {
-    // Compute hash for fraud detection, if enabled. Hash is computed only if input meets the minimum length criteria
-    if (config.fraud && id !== null && input && input.length >= Setting.WordLength) {
-        data = { id, target, checksum: hash(input, Setting.ChecksumPrecision) };
-        // Only encode this event if we haven't already reported this hash
-        if (history.indexOf(data.checksum) < 0) {
-            history.push(data.checksum);
-            encode(Event.Fraud);
-        }
-    }
-}
-
-export function stop(): void {
-    history = [];
+import { BooleanFlag, Event, IframeStatus, Metric, Setting } from "@clarity-types/data";
+import { FraudData } from "@clarity-types/diagnostic";
+import config from "@src/core/config";
+import hash from "@src/core/hash";
+import * as metric from "@src/data/metric";
+import encode from "./encode";
+
+let history = [];
+export let data: FraudData;
+
+export function start(): void {
+    history = [];
+    metric.max(Metric.Automation, navigator.webdriver ? BooleanFlag.True : BooleanFlag.False);
+    try {
+        // some sites (unintentionally) overwrite the window.self property, so we also check for the main window object
+        metric.max(Metric.Iframed, window.top == window.self || window.top == window ? IframeStatus.TopFrame : IframeStatus.Iframe);
+    } catch (ex) {
+        metric.max(Metric.Iframed, IframeStatus.Unknown);
+    }
+    
+}
+
+export function check(id: number, target: number, input: string): void {
+    // Compute hash for fraud detection, if enabled. Hash is computed only if input meets the minimum length criteria
+    if (config.fraud && id !== null && input && input.length >= Setting.WordLength) {
+        data = { id, target, checksum: hash(input, Setting.ChecksumPrecision) };
+        // Only encode this event if we haven't already reported this hash
+        if (history.indexOf(data.checksum) < 0) {
+            history.push(data.checksum);
+            encode(Event.Fraud);
+        }
+    }
+}
+
+export function stop(): void {
+    history = [];
 }

package/src/diagnostic/index.ts

@@ -1,13 +1,13 @@
-import * as fraud from "@src/diagnostic/fraud";
-import * as internal from "@src/diagnostic/internal";
-import * as script from "@src/diagnostic/script";
-
-export function start(): void {
-    fraud.start();
-    script.start();
-    internal.start();
-}
-
-export function stop(): void {
-    internal.stop();
-}
+import * as fraud from "@src/diagnostic/fraud";
+import * as internal from "@src/diagnostic/internal";
+import * as script from "@src/diagnostic/script";
+
+export function start(): void {
+    fraud.start();
+    script.start();
+    internal.start();
+}
+
+export function stop(): void {
+    internal.stop();
+}

package/src/diagnostic/internal.ts

@@ -1,28 +1,28 @@
-import { Code, Event, Severity } from "@clarity-types/data";
-import { LogData } from "@clarity-types/diagnostic";
-import encode from "./encode";
-
-let history: { [key: number]: string[] } = {};
-export let data: LogData;
-
-export function start(): void {
-    history = {};
-}
-
-export function log(code: Code, severity: Severity, name: string = null, message: string = null, stack: string = null): void {
-    let key = name ? `${name}|${message}`: "";
-    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
-    // In those cases, we only want to log the failure once and not spam logs with redundant information.
-    if (code in history && history[code].indexOf(key) >= 0) { return; }
-
-    data = { code, name, message, stack, severity };
-
-    // Maintain history of errors in memory to avoid sending redundant information
-    if (code in history) { history[code].push(key); } else { history[code] = [key]; }
-
-    encode(Event.Log);
-}
-
-export function stop(): void {
-    history = {};
-}
+import { Code, Event, Severity } from "@clarity-types/data";
+import { LogData } from "@clarity-types/diagnostic";
+import encode from "./encode";
+
+let history: { [key: number]: string[] } = {};
+export let data: LogData;
+
+export function start(): void {
+    history = {};
+}
+
+export function log(code: Code, severity: Severity, name: string = null, message: string = null, stack: string = null): void {
+    let key = name ? `${name}|${message}`: "";
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure once and not spam logs with redundant information.
+    if (code in history && history[code].indexOf(key) >= 0) { return; }
+
+    data = { code, name, message, stack, severity };
+
+    // Maintain history of errors in memory to avoid sending redundant information
+    if (code in history) { history[code].push(key); } else { history[code] = [key]; }
+
+    encode(Event.Log);
+}
+
+export function stop(): void {
+    history = {};
+}

package/src/diagnostic/script.ts

@@ -1,35 +1,35 @@
-import { Event, Setting } from "@clarity-types/data";
-import { ScriptErrorData } from "@clarity-types/diagnostic";
-import { bind } from "@src/core/event";
-import encode from "./encode";
-
-let history: { [key: string]: number } = {};
-export let data: ScriptErrorData;
-
-export function start(): void {
-    bind(window, "error", handler);
-    history = {};
-}
-
-function handler(error: ErrorEvent): boolean {
-    let e = error["error"] || error;
-    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
-    // In those cases, we only want to log the failure first few times and not spam logs with redundant information.
-    if (!(e.message in history)) { history[e.message] = 0; }
-    if (history[e.message]++ >= Setting.ScriptErrorLimit) { return true; }
-
-    // Send back information only if the handled error has valid information
-    if (e && e.message) {
-        data = {
-            message: e.message,
-            line: error["lineno"],
-            column: error["colno"],
-            stack: e.stack,
-            source: error["filename"]
-        };
-
-        encode(Event.ScriptError);
-    }
-
-    return true;
-}
+import { Event, Setting } from "@clarity-types/data";
+import { ScriptErrorData } from "@clarity-types/diagnostic";
+import { bind } from "@src/core/event";
+import encode from "./encode";
+
+let history: { [key: string]: number } = {};
+export let data: ScriptErrorData;
+
+export function start(): void {
+    bind(window, "error", handler);
+    history = {};
+}
+
+function handler(error: ErrorEvent): boolean {
+    let e = error["error"] || error;
+    // While rare, it's possible for code to fail repeatedly during the lifetime of the same page
+    // In those cases, we only want to log the failure first few times and not spam logs with redundant information.
+    if (!(e.message in history)) { history[e.message] = 0; }
+    if (history[e.message]++ >= Setting.ScriptErrorLimit) { return true; }
+
+    // Send back information only if the handled error has valid information
+    if (e && e.message) {
+        data = {
+            message: e.message,
+            line: error["lineno"],
+            column: error["colno"],
+            stack: e.stack,
+            source: error["filename"]
+        };
+
+        encode(Event.ScriptError);
+    }
+
+    return true;
+}

package/src/dynamic/agent/blank.ts

@@ -1,2 +1,2 @@
-export function start(): void {}
-export function stop(): void {}
+export function start(): void {}
+export function stop(): void {}

package/src/dynamic/agent/crisp.ts

@@ -1,40 +1,40 @@
-import { Action } from "@clarity-types/agent";
-import encode from "./encode";
-
-function open() {
-  encode(Action.AgentMaximized);
-}
-
-function close() {
-  encode(Action.AgentMinimized);
-}
-
-function human() {
-  encode(Action.HumanMessage);
-}
-
-function agent() {
-  encode(Action.AgentMessage);
-}
-
-export function start(): void {
-  if (window.$crisp) {
-    window.$crisp.push(["on", "chat:opened", open]);
-    window.$crisp.push(["on", "chat:closed", close]);
-    window.$crisp.push(["on", "message:sent", human]);
-    window.$crisp.push(["on", "message:received", agent]);
-  }
-  // Register stop callback with main Clarity
-  if (typeof window !== "undefined" && (window as any).clarity) {
-    (window as any).clarity("register", stop);
-  }
-}
-
-export function stop(): void {
-  if (window.$crisp) {
-    window.$crisp.push(["off", "chat:opened", open]);
-    window.$crisp.push(["off", "chat:closed", close]);
-    window.$crisp.push(["off", "message:sent", human]);
-    window.$crisp.push(["off", "message:received", agent]);
-  }
-}
+import { Action } from "@clarity-types/agent";
+import encode from "./encode";
+
+function open() {
+  encode(Action.AgentMaximized);
+}
+
+function close() {
+  encode(Action.AgentMinimized);
+}
+
+function human() {
+  encode(Action.HumanMessage);
+}
+
+function agent() {
+  encode(Action.AgentMessage);
+}
+
+export function start(): void {
+  if (window.$crisp) {
+    window.$crisp.push(["on", "chat:opened", open]);
+    window.$crisp.push(["on", "chat:closed", close]);
+    window.$crisp.push(["on", "message:sent", human]);
+    window.$crisp.push(["on", "message:received", agent]);
+  }
+  // Register stop callback with main Clarity
+  if (typeof window !== "undefined" && (window as any).clarity) {
+    (window as any).clarity("register", stop);
+  }
+}
+
+export function stop(): void {
+  if (window.$crisp) {
+    window.$crisp.push(["off", "chat:opened", open]);
+    window.$crisp.push(["off", "chat:closed", close]);
+    window.$crisp.push(["off", "message:sent", human]);
+    window.$crisp.push(["off", "message:received", agent]);
+  }
+}

package/src/dynamic/agent/encode.ts

@@ -1,25 +1,25 @@
-import { Event, Token } from "@clarity-types/data";
-import { Action } from "@clarity-types/agent";
-
-export default function (event: Action): void {
-  const t = (window as any).clarity("time");
-  let tokens: Token[] = [t, Event.Chat];
-  switch (event) {
-    case Action.AgentOnline:
-    case Action.AgentOffline:
-    case Action.AgentHidden:
-    case Action.AgentMaximized:
-    case Action.AgentMinimized:
-    case Action.AgentMessage:
-    case Action.HumanMessage:
-      tokens.push(event);
-      break;
-  }
-  queueTokens(tokens);
-}
-
-function queueTokens(tokens: Token[]) {
-  if (typeof window !== "undefined" && (window as any).clarity) {
-    (window as any).clarity("queue", tokens);
-  }
-}
+import { Event, Token } from "@clarity-types/data";
+import { Action } from "@clarity-types/agent";
+
+export default function (event: Action): void {
+  const t = (window as any).clarity("time");
+  let tokens: Token[] = [t, Event.Chat];
+  switch (event) {
+    case Action.AgentOnline:
+    case Action.AgentOffline:
+    case Action.AgentHidden:
+    case Action.AgentMaximized:
+    case Action.AgentMinimized:
+    case Action.AgentMessage:
+    case Action.HumanMessage:
+      tokens.push(event);
+      break;
+  }
+  queueTokens(tokens);
+}
+
+function queueTokens(tokens: Token[]) {
+  if (typeof window !== "undefined" && (window as any).clarity) {
+    (window as any).clarity("queue", tokens);
+  }
+}

package/src/dynamic/agent/index.ts

@@ -1,8 +1,8 @@
-import * as livechat from "@src/dynamic/agent/livechat";
-import * as tidio from "@src/dynamic/agent/tidio";
-import * as crisp from "@src/dynamic/agent/crisp";
-(function () {
-  livechat.start();
-  tidio.start();
-  crisp.start();
-})();
+import * as livechat from "@src/dynamic/agent/livechat";
+import * as tidio from "@src/dynamic/agent/tidio";
+import * as crisp from "@src/dynamic/agent/crisp";
+(function () {
+  livechat.start();
+  tidio.start();
+  crisp.start();
+})();