clarity-js 0.7.1 → 0.7.3

package/src/layout/mutation.ts

@@ -124,12 +124,13 @@ async function process(): Promise<void> {
   task.start(timer);
   while (mutations.length > 0) {
     let record = mutations.shift();
+    let instance = time();
     for (let mutation of record.mutations) {
       let state = task.state(timer);
       if (state === Task.Wait) { state = await task.suspend(timer); }
       if (state === Task.Stop) { break; }      
       let target = mutation.target;
-      let type = track(mutation, timer);
+      let type = track(mutation, timer, instance);
       if (type && target && target.ownerDocument) { dom.parse(target.ownerDocument); }
       if (type && target && target.nodeType == Node.DOCUMENT_FRAGMENT_NODE && (target as ShadowRoot).host) { dom.parse(target as ShadowRoot); }
       switch (type) {
@@ -156,7 +157,7 @@ async function process(): Promise<void> {
   task.stop(timer);
 }
 
-function track(m: MutationRecord, timer: Timer): string {
+function track(m: MutationRecord, timer: Timer, instance: number): string {
   let value = m.target ? dom.get(m.target.parentNode) : null;
   // Check if the parent is already discovered and that the parent is not the document root
   if (value && value.data.tag !== Constant.HTML) {
@@ -169,19 +170,22 @@ function track(m: MutationRecord, timer: Timer): string {
     // In those cases, IDs will change however the selector (which is relative to DOM xPath) remains the same
     let key = [parent, element, m.attributeName, names(m.addedNodes), names(m.removedNodes)].join();
     // Initialize an entry if it doesn't already exist
-    history[key] = key in history ? history[key] : [0];
+    history[key] = key in history ? history[key] : [0, instance];
     let h = history[key];
     // Lookup any pending nodes queued up for removal, and process them now if we suspended a mutation before
-    if (inactive === false && h[0] >= Setting.MutationSuspendThreshold) { processNodeList(h[1], Source.ChildListRemove, timer); }
+    if (inactive === false && h[0] >= Setting.MutationSuspendThreshold) { processNodeList(h[2], Source.ChildListRemove, timer); }
     // Update the counter
-    h[0] = inactive ? h[0] + 1 : 1;
+    h[0] = inactive ? (h[1] === instance ? h[0] : h[0] + 1) : 1;
+    h[1] = instance;
     // Return updated mutation type based on if we have already hit the threshold or not
     if (h[0] === Setting.MutationSuspendThreshold) {
       // Store a reference to removedNodes so we can process them later
       // when we resume mutations again on user interactions
-      h[1] = m.removedNodes;
+      h[2] = m.removedNodes;
       return Constant.Suspend;
-    } else if (h[0] > Setting.MutationSuspendThreshold) { return Constant.Empty; }
+    } else if (h[0] > Setting.MutationSuspendThreshold) { 
+      return Constant.Empty; 
+    }
   }
   return m.type;
 }

package/src/performance/observer.ts

@@ -1,4 +1,4 @@
-import { Code, Constant, Dimension, Metric, Setting, Severity } from "@clarity-types/data";
+import { Code, Constant, Dimension, Metric, Severity } from "@clarity-types/data";
 import config from "@src/core/config";
 import { bind } from "@src/core/event";
 import measure from "@src/core/measure";
@@ -81,11 +81,6 @@ function process(entries: PerformanceEntryList): void {
                 break;
         }
     }
-    if (performance && Constant.Memory in performance && performance[Constant.Memory].usedJSHeapSize) {
-        // Track consumed memory (MBs) where "memory" API is available
-        // Reference: https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
-        metric.max(Metric.UsedMemory, Math.abs(performance[Constant.Memory].usedJSHeapSize / Setting.MegaByte));
-    }
 }
 
 export function stop(): void {

package/src/queue.ts

@@ -0,0 +1,31 @@
+import { Constant } from "@clarity-types/data";
+import * as clarity from "@src/clarity";
+
+const w = window; 
+const c = Constant.Clarity;
+
+export function setup() {
+    // Start queuing up calls while Clarity is inactive and we are in a browser enviornment    
+    if (typeof w !== "undefined") {
+        w[c] = function() {
+            (w[c].q = w[c].q || []).push(arguments);
+        };
+    }
+}
+
+export function process() {
+    if (typeof w !== "undefined") {
+        // Do not execute or reset global "clarity" variable if a version of Clarity is already running on the page
+        if (w[c] && w[c].v) { return console.warn("Error CL001: Multiple Clarity tags detected."); }
+
+        // Expose clarity in a browser environment
+        // To be efficient about queuing up operations while Clarity is wiring up, we expose clarity.*(args) => clarity(*, args);
+        // This allows us to reprocess any calls that we missed once Clarity is available on the page
+        // Once Clarity script bundle is loaded on the page, we also initialize a "v" property that holds current version
+        // We use the presence or absence of "v" to determine if we are attempting to run a duplicate instance
+        let queue = w[c] ? (w[c].q || []) : [];
+        w[c] = function(method: string, ...args: any[]): void { return clarity[method](...args); }
+        w[c].v = clarity.version;
+        while (queue.length > 0) { w[c](...queue.shift()); }
+    }
+}

package/tsconfig.json

@@ -16,6 +16,6 @@
             "@clarity-types/*": ["types/*"]
         }
     },
-    "include":["src/**/*.ts","types/**/*.d.ts"],
+    "include":["src/**/*.ts","types/**/*.d.ts", "rollup.config.ts"],
     "exclude": ["test", "node_modules", "build"]
 }

package/types/data.d.ts

@@ -97,6 +97,9 @@ export const enum Metric {
     Mobile = 27,
     UploadTime = 28,
     SinglePage = 29,
+/**
+ * @deprecated Browser API is deprecated. Reference: https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
+ */
     UsedMemory = 30,
     Iframed = 31,
     MaxTouchPoints = 32,

package/types/layout.d.ts

@@ -186,7 +186,7 @@ export interface MutationQueue {
 }
 
 export interface MutationHistory {
-    [key: string]: [/* Count */ number, /* Remove Nodes Buffer */ NodeList?];
+    [key: string]: [/* Count */ number, /* Instance */ number, /* Remove Nodes Buffer */ NodeList?];
 }
 
 export interface RegionQueue {