clarity-js 0.7.67 → 0.7.69

package/src/interaction/click.ts

@@ -1,5 +1,5 @@
 import { BooleanFlag, Constant, Event, Setting } from "@clarity-types/data";
-import { BrowsingContext, ClickState } from "@clarity-types/interaction";
+import { BrowsingContext, ClickState, TextInfo } from "@clarity-types/interaction";
 import { Box } from "@clarity-types/layout";
 import { FunctionNames } from "@clarity-types/performance";
 import { bind } from "@src/core/event";
@@ -55,6 +55,7 @@ function handler(event: Event, root: Node, evt: MouseEvent): void {
 
     // Check for null values before processing this event
     if (x !== null && y !== null) {
+        const textInfo = text(t);
         state.push({
             time: time(evt), event, data: {
                 target: t,
@@ -65,10 +66,11 @@ function handler(event: Event, root: Node, evt: MouseEvent): void {
                 button: evt.button,
                 reaction: reaction(t),
                 context: context(a),
-                text: text(t),
+                text: textInfo.text,
                 link: a ? a.href : null,
                 hash: null,
-                trust: evt.isTrusted ? BooleanFlag.True : BooleanFlag.False
+                trust: evt.isTrusted ? BooleanFlag.True : BooleanFlag.False,
+                isFullText: textInfo.isFullText,
             }
         });
         schedule(encode.bind(this, event));
@@ -88,19 +90,23 @@ function link(node: Node): HTMLAnchorElement {
     return null;
 }
 
-function text(element: Node): string {
+function text(element: Node): TextInfo {
     let output = null;
+    let isFullText = false;
     if (element) {
         // Grab text using "textContent" for most HTMLElements, however, use "value" for HTMLInputElements and "alt" for HTMLImageElement.
         let t = element.textContent || String((element as HTMLInputElement).value || '') || (element as HTMLImageElement).alt;
         if (t) {
             // Replace multiple occurrence of space characters with a single white space
             // Also, trim any spaces at the beginning or at the end of string
+            const trimmedText =  t.replace(/\s+/g, Constant.Space).trim();
             // Finally, send only first few characters as specified by the Setting
-            output = t.replace(/\s+/g, Constant.Space).trim().substr(0, Setting.ClickText);
+            output = trimmedText.substring(0, Setting.ClickText);
+            isFullText = output.length === trimmedText.length;
         }
     }
-    return output;
+
+    return { text: output, isFullText: isFullText ? BooleanFlag.True : BooleanFlag.False };
 }
 
 function reaction(element: Node): BooleanFlag {

package/src/interaction/encode.ts

@@ -67,6 +67,7 @@ export default async function (type: Event, ts: number = null): Promise<void> {
                 tokens.push(scrub.url(entry.data.link));
                 tokens.push(cHash);
                 tokens.push(entry.data.trust);
+                tokens.push(entry.data.isFullText);
                 queue(tokens);
                 timeline.track(entry.time, entry.event, cHash, entry.data.x, entry.data.y, entry.data.reaction, entry.data.context);
             }
@@ -95,6 +96,7 @@ export default async function (type: Event, ts: number = null): Promise<void> {
         case Event.Unload:
             let u = unload.data;
             tokens.push(u.name);
+            tokens.push(u.persisted);
             unload.reset();
             queue(tokens);
             break;

package/src/interaction/timeline.ts

@@ -39,7 +39,7 @@ export function track(time: number,
     // Since timeline only keeps the data for configured time, we still want to continue tracking these values
     // as part of the baseline. For instance, in a scenario where last scroll happened 5s ago.
     // We would still need to capture the last scroll position as part of the baseline event, even when timeline will be empty.
-    baseline.track(event, x, y);
+    baseline.track(event, x, y, time);
 }
 
 export function compute(): void {

package/src/interaction/unload.ts

@@ -1,4 +1,4 @@
-import { Event } from "@clarity-types/data";
+import { BooleanFlag, Event } from "@clarity-types/data";
 import { UnloadData } from "@clarity-types/interaction";
 import { FunctionNames } from "@clarity-types/performance";
 import * as clarity from "@src/clarity";
@@ -12,9 +12,9 @@ export function start(): void {
     bind(window, "pagehide", recompute);
 }
 
-function recompute(evt: UIEvent): void {
+function recompute(evt: PageTransitionEvent): void {
     recompute.dn = FunctionNames.UnloadRecompute;
-    data = { name: evt.type };
+    data = { name: evt.type, persisted: evt.persisted ? BooleanFlag.True : BooleanFlag.False };
     encode(Event.Unload, time(evt));
     clarity.stop();
 }

package/src/layout/mutation.ts

@@ -26,7 +26,7 @@ let mutations: MutationQueue[] = [];
 let throttledMutations: { [key: number]: MutationRecordWithTime } = {};
 let insertRule: (rule: string, index?: number) => number = null;
 let deleteRule: (index?: number) => void = null;
-let attachShadow: (init: ShadowRootInit)  => ShadowRoot = null;
+let attachShadow: (init: ShadowRootInit) => ShadowRoot = null;
 let mediaInsertRule: (rule: string, index?: number) => number = null;
 let mediaDeleteRule: (index?: number) => void = null;
 let queue: Node[] = [];
@@ -36,63 +36,79 @@ let activePeriod = null;
 let history: MutationHistory = {};
 let criticalPeriod = null;
 
+// We ignore mutations if these attributes are updated
+const IGNORED_ATTRIBUTES = ["data-google-query-id", "data-load-complete", "data-google-container-id"];
+
 export function start(): void {
-    start.dn = FunctionNames.MutationStart;
-    observers = [];
-    queue = [];
-    timeout = null;
-    activePeriod = 0;
-    history = {};
-    criticalPeriod = 0;
-
-    // Some popular open source libraries, like styled-components, optimize performance
-    // by injecting CSS using insertRule API vs. appending text node. A side effect of
-    // using javascript API is that it doesn't trigger DOM mutation and therefore we
-    // need to override the insertRule API and listen for changes manually.
-    if (insertRule === null) { 
-      insertRule = CSSStyleSheet.prototype.insertRule; 
-      CSSStyleSheet.prototype.insertRule = function(): number {
-        if (core.active()) { schedule(this.ownerNode); }
-        return insertRule.apply(this, arguments);
-      };
-    }
+  start.dn = FunctionNames.MutationStart;
+  observers = [];
+  queue = [];
+  timeout = null;
+  activePeriod = 0;
+  history = {};
+  criticalPeriod = 0;
 
-    if ("CSSMediaRule" in window && mediaInsertRule === null) { 
-      mediaInsertRule = CSSMediaRule.prototype.insertRule; 
-      CSSMediaRule.prototype.insertRule = function(): number {
-        if (core.active()) { schedule(this.parentStyleSheet.ownerNode); }
-        return mediaInsertRule.apply(this, arguments);
-      };
-    }
+  // Some popular open source libraries, like styled-components, optimize performance
+  // by injecting CSS using insertRule API vs. appending text node. A side effect of
+  // using javascript API is that it doesn't trigger DOM mutation and therefore we
+  // need to override the insertRule API and listen for changes manually.
+  if (insertRule === null) {
+    insertRule = CSSStyleSheet.prototype.insertRule;
+    CSSStyleSheet.prototype.insertRule = function (): number {
+      if (core.active()) {
+        schedule(this.ownerNode);
+      }
+      return insertRule.apply(this, arguments);
+    };
+  }
 
-    if (deleteRule === null) { 
-      deleteRule = CSSStyleSheet.prototype.deleteRule;
-      CSSStyleSheet.prototype.deleteRule = function(): void {
-        if (core.active()) { schedule(this.ownerNode); }
-        return deleteRule.apply(this, arguments);
-      };
-    }
+  if ("CSSMediaRule" in window && mediaInsertRule === null) {
+    mediaInsertRule = CSSMediaRule.prototype.insertRule;
+    CSSMediaRule.prototype.insertRule = function (): number {
+      if (core.active()) {
+        schedule(this.parentStyleSheet.ownerNode);
+      }
+      return mediaInsertRule.apply(this, arguments);
+    };
+  }
+
+  if (deleteRule === null) {
+    deleteRule = CSSStyleSheet.prototype.deleteRule;
+    CSSStyleSheet.prototype.deleteRule = function (): void {
+      if (core.active()) {
+        schedule(this.ownerNode);
+      }
+      return deleteRule.apply(this, arguments);
+    };
+  }
+
+  if ("CSSMediaRule" in window && mediaDeleteRule === null) {
+    mediaDeleteRule = CSSMediaRule.prototype.deleteRule;
+    CSSMediaRule.prototype.deleteRule = function (): void {
+      if (core.active()) {
+        schedule(this.parentStyleSheet.ownerNode);
+      }
+      return mediaDeleteRule.apply(this, arguments);
+    };
+  }
 
-    if ("CSSMediaRule" in window && mediaDeleteRule === null) { 
-      mediaDeleteRule = CSSMediaRule.prototype.deleteRule;
-      CSSMediaRule.prototype.deleteRule = function(): void {
-        if (core.active()) { schedule(this.parentStyleSheet.ownerNode); }
-        return mediaDeleteRule.apply(this, arguments);
+  // Add a hook to attachShadow API calls
+  // In case we are unable to add a hook and browser throws an exception,
+  // reset attachShadow variable and resume processing like before
+  if (attachShadow === null) {
+    attachShadow = Element.prototype.attachShadow;
+    try {
+      Element.prototype.attachShadow = function (): ShadowRoot {
+        if (core.active()) {
+          return schedule(attachShadow.apply(this, arguments)) as ShadowRoot;
+        } else {
+          return attachShadow.apply(this, arguments);
+        }
       };
+    } catch {
+      attachShadow = null;
     }
-
-   // Add a hook to attachShadow API calls
-   // In case we are unable to add a hook and browser throws an exception,
-   // reset attachShadow variable and resume processing like before
-   if (attachShadow === null) { 
-     attachShadow = Element.prototype.attachShadow;    
-     try {
-       Element.prototype.attachShadow = function (): ShadowRoot {
-         if (core.active()) { return schedule(attachShadow.apply(this, arguments)) as ShadowRoot; }
-         else { return attachShadow.apply(this, arguments)}   
-       }
-     } catch { attachShadow = null; }
-  } 
+  }
 }
 
 export function observe(node: Node): void {
@@ -102,12 +118,14 @@ export function observe(node: Node): void {
   // Also, wrap it inside a try / catch. In certain browsers (e.g. legacy Edge), observer on shadow dom can throw errors
   try {
     let m = api(Constant.MutationObserver);
-    let observer =  m in window ? new window[m](measure(handle) as MutationCallback) : null;
+    let observer = m in window ? new window[m](measure(handle) as MutationCallback) : null;
     if (observer) {
       observer.observe(node, { attributes: true, childList: true, characterData: true, subtree: true });
       observers.push(observer);
     }
-  } catch (e) { internal.log(Code.MutationObserver, Severity.Info, e ? e.name : null); }
+  } catch (e) {
+    internal.log(Code.MutationObserver, Severity.Info, e ? e.name : null);
+  }
 }
 
 export function monitor(frame: HTMLIFrameElement): void {
@@ -120,7 +138,11 @@ export function monitor(frame: HTMLIFrameElement): void {
 }
 
 export function stop(): void {
-  for (let observer of observers) { if (observer) { observer.disconnect(); } }
+  for (let observer of observers) {
+    if (observer) {
+      observer.disconnect();
+    }
+  }
   observers = [];
   history = {};
   mutations = [];
@@ -141,28 +163,43 @@ function handle(m: MutationRecord[]): void {
   // Queue up mutation records for asynchronous processing
   let now = time();
   summary.track(Event.Mutation, now);
-  mutations.push({ time: now, mutations: m});
+  mutations.push({ time: now, mutations: m });
   task.schedule(process, Priority.High).then((): void => {
-      setTimeout(doc.compute)
-      measure(region.compute)();
+    setTimeout(doc.compute);
+    measure(region.compute)();
   });
 }
 
 async function processMutation(timer: Timer, mutation: MutationRecord, instance: number, timestamp: number): Promise<void> {
   let state = task.state(timer);
-  if (state === Task.Wait) { state = await task.suspend(timer); }
-  if (state === Task.Stop) { return; }      
+
+  if (state === Task.Wait) {
+    state = await task.suspend(timer);
+  }
+  if (state === Task.Stop) {
+    return;
+  }
+
   let target = mutation.target;
   let type = config.throttleDom ? track(mutation, timer, instance, timestamp) : mutation.type;
-  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); }
+
+  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) {
     case Constant.Attributes:
+      if (IGNORED_ATTRIBUTES.indexOf(mutation.attributeName) < 0) {
         processNode(target, Source.Attributes, timestamp);
-        break;
+      }
+      break;
     case Constant.CharacterData:
-        processNode(target, Source.CharacterData, timestamp);
-        break;
+      processNode(target, Source.CharacterData, timestamp);
+      break;
     case Constant.ChildList:
       processNodeList(mutation.addedNodes, Source.ChildListAdd, timer, timestamp);
       processNodeList(mutation.removedNodes, Source.ChildListRemove, timer, timestamp);
@@ -179,7 +216,7 @@ async function process(): Promise<void> {
     let record = mutations.shift();
     let instance = time();
     for (let mutation of record.mutations) {
-      await processMutation(timer, mutation, instance, record.time)
+      await processMutation(timer, mutation, instance, record.time);
     }
     await encode(Event.Mutation, timer, record.time);
   }
@@ -202,13 +239,13 @@ async function process(): Promise<void> {
   }
 
   cleanHistory();
-  
+
   task.stop(timer);
 }
 
 function cleanHistory(): void {
   let now = time();
-  if (Object.keys(history).length > Setting.MaxMutationHistoryCount) { 
+  if (Object.keys(history).length > Setting.MaxMutationHistoryCount) {
     history = {};
     metric.count(Metric.HistoryClear);
   }
@@ -223,33 +260,40 @@ function cleanHistory(): void {
 
 function track(m: MutationRecord, timer: Timer, instance: number, timestamp: 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) {
     // calculate inactive period based on the timestamp of the mutation not when the mutation is processed
     let inactive = timestamp > activePeriod;
+
     // Calculate critical period based on when mutation is processed
     const critical = instance < criticalPeriod;
     let target = dom.get(m.target);
     let element = target && target.selector ? target.selector.join() : m.target.nodeName;
     let parent = value.selector ? value.selector.join() : Constant.Empty;
+
     // Check if its a low priority (e.g., ads related) element mutation happening during critical period
     // If the discard list is empty, we discard all mutations during critical period
-    const lowPriMutation =
-      config.throttleMutations && critical &&
-      (config.discard.length === 0 || config.discard.some((key) => element.includes(key)));
+    const lowPriMutation = config.throttleMutations && critical && (config.discard.length === 0 || config.discard.some((key) => element.includes(key)));
+
     // We use selector, instead of id, to determine the key (signature for the mutation) because in some cases
     // repeated mutations can cause elements to be destroyed and then recreated as new DOM nodes
     // 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, 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[2], Source.ChildListRemove, timer, timestamp); }
-    
+    if (inactive === false && h[0] >= Setting.MutationSuspendThreshold) {
+      processNodeList(h[2], Source.ChildListRemove, timer, timestamp);
+    }
+
     // Update the counter, do not reset counter if its critical period
     h[0] = inactive || lowPriMutation ? (h[1] === instance ? h[0] : h[0] + 1) : 1;
     h[1] = instance;
+
     // Return updated mutation type based on,
     // 1. if we have already hit the threshold or not
     // 2. if its a low priority mutation happening during critical time period
@@ -260,11 +304,13 @@ function track(m: MutationRecord, timer: Timer, instance: number, timestamp: num
       if (instance > timestamp + Setting.MutationActivePeriod) {
         return m.type;
       }
+
       if (!config.dropMutations) {
         // we only store the most recent mutation for a given key if it is being throttled
-        throttledMutations[key] = {mutation: m, timestamp};
+        throttledMutations[key] = { mutation: m, timestamp };
       }
-      return Constant.Throttle; 
+
+      return Constant.Throttle;
     }
   }
   return m.type;
@@ -272,7 +318,9 @@ function track(m: MutationRecord, timer: Timer, instance: number, timestamp: num
 
 function names(nodes: NodeList): string {
   let output: string[] = [];
-  for (let i = 0; nodes && i < nodes.length; i++) { output.push(nodes[i].nodeName); }
+  for (let i = 0; nodes && i < nodes.length; i++) {
+    output.push(nodes[i].nodeName);
+  }
   return output.join();
 }
 
@@ -284,8 +332,12 @@ async function processNodeList(list: NodeList, source: Source, timer: Timer, tim
       traverse(node, timer, source, timestamp);
     } else {
       let state = task.state(timer);
-      if (state === Task.Wait) { state = await task.suspend(timer); }
-      if (state === Task.Stop) { break; }
+      if (state === Task.Wait) {
+        state = await task.suspend(timer);
+      }
+      if (state === Task.Stop) {
+        break;
+      }
       processNode(node, source, timestamp);
     }
   }
@@ -295,18 +347,26 @@ function processThrottledMutations(): void {
   if (throttleDelay) {
     clearTimeout(throttleDelay);
   }
-  throttleDelay = setTimeout(() => { task.schedule(process, Priority.High) }, Setting.LookAhead);
+  throttleDelay = setTimeout(() => {
+    task.schedule(process, Priority.High);
+  }, Setting.LookAhead);
 }
 
 export function schedule(node: Node): Node {
   // Only schedule manual trigger for this node if it's not already in the queue
-  if (queue.indexOf(node) < 0) { queue.push(node); }
+  if (queue.indexOf(node) < 0) {
+    queue.push(node);
+  }
 
   // Cancel any previous trigger before scheduling a new one.
   // It's common for a webpage to call multiple synchronous "insertRule" / "deleteRule" calls.
   // And in those cases we do not wish to monitor changes multiple times for the same node.
-  if (timeout) { clearTimeout(timeout); }
-  timeout = setTimeout(() => { trigger() }, Setting.LookAhead);
+  if (timeout) {
+    clearTimeout(timeout);
+  }
+  timeout = setTimeout(() => {
+    trigger();
+  }, Setting.LookAhead);
 
   return node;
 }
@@ -317,7 +377,9 @@ function trigger(): void {
     if (node) {
       let shadowRoot = node.nodeType === Node.DOCUMENT_FRAGMENT_NODE;
       // Skip re-processing shadowRoot if it was already discovered
-      if (shadowRoot && dom.has(node)) { continue; }
+      if (shadowRoot && dom.has(node)) {
+        continue;
+      }
       generate(node, shadowRoot ? Constant.ChildList : Constant.CharacterData);
     }
   }
@@ -326,15 +388,17 @@ function trigger(): void {
 
 function generate(target: Node, type: MutationRecordType): void {
   generate.dn = FunctionNames.MutationGenerate;
-  measure(handle)([{
-    addedNodes: [target],
-    attributeName: null,
-    attributeNamespace: null,
-    nextSibling: null,
-    oldValue: null,
-    previousSibling: null,
-    removedNodes: [],
-    target,
-    type
-  }]);
+  measure(handle)([
+    {
+      addedNodes: [target],
+      attributeName: null,
+      attributeNamespace: null,
+      nextSibling: null,
+      oldValue: null,
+      previousSibling: null,
+      removedNodes: [],
+      target,
+      type,
+    },
+  ]);
 }

package/src/layout/style.ts

@@ -1,7 +1,7 @@
 import { Event, Metric } from "@clarity-types/data";
 import { StyleSheetOperation, StyleSheetState } from "@clarity-types/layout";
 import { time } from "@src/core/time";
-import { shortid, data as metadataFields } from "@src/data/metadata";
+import { shortid } from "@src/data/metadata";
 import encode from "@src/layout/encode";
 import { getId } from "@src/layout/dom";
 import * as core from "@src/core";
@@ -13,10 +13,10 @@ export let sheetAdoptionState: StyleSheetState[] = [];
 let replace: (text?: string) => Promise<CSSStyleSheet> = null;
 let replaceSync: (text?: string) => void = null;
 const styleSheetId = 'claritySheetId';
-const styleSheetPageNum = 'claritySheetNum';
 let styleSheetMap = {};
 let styleTimeMap: {[key: string]: number} = {};
 let documentNodes = [];
+let createdSheetIds = [];
 
 export function start(): void {
     if (window['CSSStyleSheet'] && CSSStyleSheet.prototype) {
@@ -28,7 +28,7 @@ export function start(): void {
                     // if we haven't seen this stylesheet on this page yet, wait until the checkDocumentStyles has found it
                     // and attached the sheet to a document. This way the timestamp of the style sheet creation will align
                     // to when it is used in the document rather than potentially being misaligned during the traverse process.
-                    if (this[styleSheetPageNum] === metadataFields.pageNum) {
+                    if (createdSheetIds.indexOf(this[styleSheetId]) > -1) {
                         trackStyleChange(time(), this[styleSheetId], StyleSheetOperation.Replace, arguments[0]);
                     }
                 }
@@ -44,7 +44,7 @@ export function start(): void {
                     // if we haven't seen this stylesheet on this page yet, wait until the checkDocumentStyles has found it
                     // and attached the sheet to a document. This way the timestamp of the style sheet creation will align
                     // to when it is used in the document rather than potentially being misaligned during the traverse process.
-                    if (this[styleSheetPageNum] === metadataFields.pageNum) {
+                    if (createdSheetIds.indexOf(this[styleSheetId]) > -1) {
                         trackStyleChange(time(), this[styleSheetId], StyleSheetOperation.ReplaceSync, arguments[0]);
                     }                
                 }
@@ -66,17 +66,17 @@ export function checkDocumentStyles(documentNode: Document, timestamp: number):
     metric.max(Metric.ConstructedStyles, 1);
     let currentStyleSheets: string[] = [];
     for (var styleSheet of documentNode.adoptedStyleSheets) {
-        const pageNum = metadataFields.pageNum;
         // If we haven't seen this style sheet on this page yet, we create a reference to it for the visualizer.
         // For SPA or times in which Clarity restarts on a given page, our visualizer would lose context
         // on the previously created style sheet for page N-1.
         // Then we synthetically call replaceSync with its contents to bootstrap it
-        if (styleSheet[styleSheetPageNum] !== pageNum) {
-            styleSheet[styleSheetPageNum] = pageNum;
+        if (!styleSheet[styleSheetId] || createdSheetIds.indexOf(styleSheet[styleSheetId]) === -1) {
             styleSheet[styleSheetId] = shortid();
+            createdSheetIds.push(styleSheet[styleSheetId]);
             trackStyleChange(timestamp, styleSheet[styleSheetId], StyleSheetOperation.Create);
             trackStyleChange(timestamp, styleSheet[styleSheetId], StyleSheetOperation.ReplaceSync, getCssRules(styleSheet));
         }
+
         currentStyleSheets.push(styleSheet[styleSheetId]);
     }
 
@@ -109,6 +109,7 @@ export function stop(): void {
     styleSheetMap = {};
     styleTimeMap = {};
     documentNodes = [];
+    createdSheetIds = [];
     reset();
 }
 

package/types/core.d.ts

@@ -101,7 +101,10 @@ export interface BrowserEvent {
     event: string;
     target: EventTarget;
     listener: EventListener;
-    capture: boolean;
+    options: {
+        capture: boolean;
+        passive: boolean;
+    };
 }
 
 export interface Report {

package/types/data.d.ts

@@ -433,6 +433,12 @@ export interface BaselineData {
     downX: number;
     downY: number;
     downTime: number;
+    upX: number;
+    upY: number;
+    upTime: number;
+    pointerPrevX: number;
+    pointerPrevY: number;
+    pointerPrevTime: number;
 }
 
 export interface IdentityData {

package/types/interaction.d.ts

@@ -1,3 +1,4 @@
+import { BooleanFlag } from "@clarity-types/data";
 import { Time } from "./core";
 import { Event, Target } from "./data";
 
@@ -121,6 +122,12 @@ export interface ClickData {
     link: string;
     hash: string;
     trust: number;
+    isFullText: BooleanFlag;
+}
+
+export interface TextInfo {
+    text: string;
+    isFullText: BooleanFlag;
 }
 
 export interface ClipboardData {
@@ -150,6 +157,7 @@ export interface SelectionData {
 
 export interface UnloadData {
     name: string;
+    persisted: BooleanFlag;
 }
 
 export interface VisibilityData {