clarity-js 0.7.6 → 0.7.8

package/src/core/scrub.ts

@@ -64,7 +64,7 @@ export function text(value: string, hint: string, privacy: Privacy, mangle: bool
                 switch (hint) {
                     case Layout.Constant.TextTag:
                     case Layout.Constant.DataAttribute:
-                        return scrub(value);
+                        return scrub(value, Data.Constant.Letter, Data.Constant.Digit);
                     case "value":
                     case "input":
                     case "click":
@@ -83,7 +83,10 @@ export function text(value: string, hint: string, privacy: Privacy, mangle: bool
     return value;
 }
 
-export function url(input: string): string {
+export function url(input: string, electron: boolean = false): string {
+    // Replace the URL for Electron apps so we don't send back file:/// URL
+    if (electron) { return `${Data.Constant.HTTPS}${Data.Constant.Electron}`; }
+
     let drop = config.drop;
     if (drop && drop.length > 0 && input && input.indexOf("?") > 0) {
       let [path, query] = input.split("?");
@@ -109,9 +112,9 @@ function mask(value: string): string {
     return value.replace(catchallRegex, Data.Constant.Mask);
 }
 
-function scrub(value: string): string {
+export function scrub(value: string, letter: string, digit: string): string {
     regex(); // Initialize regular expressions
-    return value.replace(letterRegex, Data.Constant.Letter).replace(digitRegex, Data.Constant.Digit);
+    return value ? value.replace(letterRegex, letter).replace(digitRegex, digit) : value;
 }
 
 function mangleToken(value: string): string {
@@ -161,7 +164,7 @@ function redact(value: string): string {
                 // Check if unicode regex is supported, otherwise fallback to calling mask function on this token
                 if (unicodeRegex && currencyRegex !== null) {
                     // Do not redact information if the token contains a currency symbol
-                    token = token.match(currencyRegex) ? token : token.replace(letterRegex, Data.Constant.Letter).replace(digitRegex, Data.Constant.Digit);
+                    token = token.match(currencyRegex) ? token : scrub(token, Data.Constant.Letter, Data.Constant.Digit);
                 } else {
                     token = mask(token);
                 }

package/src/core/version.ts

@@ -1,2 +1,2 @@
-let version = "0.7.6";
+let version = "0.7.8";
 export default version;

package/src/data/encode.ts

@@ -108,10 +108,17 @@ export default function(event: Event): void {
             break;
         case Event.Extract:
             let extractKeys = extract.keys;
-            for (let e of extractKeys) {
+            extractKeys.forEach((e => {
                 tokens.push(e);
-                tokens.push([].concat(...extract.data[e]));
-            }
+                let token = []
+                for (let d in extract.data[e]) {
+                    let key = parseInt(d, 10);
+                    token.push(key);
+                    token.push(extract.data[e][d]);
+                }
+                tokens.push(token);
+            }));
+            
             extract.reset();
             queue(tokens, false);
     }

package/src/data/extract.ts

@@ -3,16 +3,23 @@ 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";
 
 export let data: ExtractData = {};
-export let keys: number[] = [];
+export let keys: Set<number> = new Set();
 
 let variables : { [key: number]: { [key: number]: Syntax[] }} = {};
 let selectors : { [key: number]: { [key: number]: string }} = {};
+let hashes : { [key: number]: { [key: number]: string }} = {};
 export function start(): void {
     reset();
 }
 
+// Input string is of the following form:
+// EXTRACT 101 { "1": ".class1", "2": "~window.a.b", "3": "!abc"}
+// Which 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 { 
     try {
         var parts = input && input.length > 0 ? input.split(/ (.*)/) : [Constant.Empty];
@@ -20,10 +27,18 @@ export function trigger(input: string): void {
         var values = parts.length > 1 ? JSON.parse(parts[1]) : {};
         variables[key] = {};
         selectors[key] = {};
+        hashes[key] = {};
         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
             let id = parseInt(v);
             let value = values[v] as string;
-            let source = value.startsWith(Constant.Tilde) ? ExtractSource.Javascript : ExtractSource.Text;
+            let source = ExtractSource.Text;
+            if (value.startsWith(Constant.Tilde)) {
+                source = ExtractSource.Javascript
+            } else if (value.startsWith(Constant.Bang)) {
+                source = ExtractSource.Hash
+            }
             switch (source) {
                 case ExtractSource.Javascript:
                     let variable = value.substring(1, value.length);
@@ -32,6 +47,10 @@ export function trigger(input: string): void {
                 case ExtractSource.Text:
                     selectors[key][id] = value;
                     break;
+                case ExtractSource.Hash:
+                    let hash = value.substring(1, value.length);
+                    hashes[key][id] = hash;
+                    break;
             }
         }
     }
@@ -48,44 +67,63 @@ export function compute(): void {
     try {
         for (let v in variables) {
             let key = parseInt(v);
-            if (!(key in keys)) {
-                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); }
+            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);
                 }
+            }
 
-                let selectorData = selectors[key];
-                for (let s in selectorData) {
-                    let selectorKey = parseInt(s);
-                    let nodes = document.querySelectorAll(selectorData[selectorKey]) as NodeListOf<HTMLElement>;
-                    if (nodes) {
-                        let text = Array.from(nodes).map(e => e.innerText)
-                        update(key, selectorKey, text.join(Constant.Seperator).substring(0, Setting.ExtractLimit));
-                    }
+            let selectorData = selectors[key];
+            for (let s in selectorData) {
+                let selectorKey = parseInt(s);
+                let nodes = document.querySelectorAll(selectorData[selectorKey]) as NodeListOf<HTMLElement>;
+                if (nodes) {
+                    let text = Array.from(nodes).map(e => e.textContent)
+                    update(key, selectorKey, text.join(Constant.Seperator).substring(0, Setting.ExtractLimit));
                 }
             }
+
+            let hashData = hashes[key];
+            for (let h in hashData) {
+                let hashKey = parseInt(h);
+                let content = hashText(hashData[hashKey]).trim().substring(0, Setting.ExtractLimit);
+                update(key, hashKey, content);
+            }            
+        }
+
+        if (keys.size > 0) {
+            encode(Event.Extract);
         }
     }
     catch (e) { internal.log(Code.Selector, Severity.Warning, e ? e.name : null); }
-
-    encode(Event.Extract);
 }
 
 export function reset(): void {
-    data = {};
-    keys = [];
-    variables = {};
-    selectors = {};
+    keys.clear();
 }
 
-export function update(key: number, subkey: number,  value: string): void {
+export function update(key: number, subkey: number, value: string): void {
+    var update = false;
     if (!(key in data)) {
-        data[key] = []
-        keys.push(key);
+        data[key] = {};
+        update = true;
     }
-    data[key].push([subkey, value]);
+    
+    if (!isEmpty(hashes[key]) 
+        && (!(subkey in data[key]) || data[key][subkey] != value))
+    {
+        update = true;
+    }
+
+    data[key][subkey] = value;
+    if (update) {
+        keys.add(key);
+    }
+
+    return;
 }
 
 export function stop(): void {
@@ -151,4 +189,8 @@ function match(base: Object, condition: string): boolean {
     }
 
     return true;
-}
+}
+
+function isEmpty(obj: Object): boolean {
+    return Object.keys(obj).length == 0;
+}

package/src/data/limit.ts

@@ -15,6 +15,7 @@ export function check(bytes: number): void {
     if (data.check === Check.None) {
         let reason = data.check;
         reason = envelope.data.sequence >= Setting.PayloadLimit ? Check.Payload : reason;
+        reason = envelope.data.pageNum >= Setting.PageLimit ? Check.Page : reason;
         reason = time() > Setting.ShutdownLimit ? Check.Shutdown : reason;
         reason = bytes > Setting.PlaybackBytesLimit ? Check.Shutdown : reason;
         if (reason !== data.check) {

package/src/data/metadata.ts

@@ -16,6 +16,7 @@ export function start(): void {
   rootDomain = null;
   const ua = navigator && "userAgent" in navigator ? navigator.userAgent : Constant.Empty;
   const title = document && document.title ? document.title : Constant.Empty;
+  const electron = ua.indexOf(Constant.Electron) > 0 ? BooleanFlag.True : BooleanFlag.False;
 
   // Populate ids for this page
   let s = session();
@@ -26,20 +27,23 @@ export function start(): void {
   // Override configuration based on what's in the session storage, unless it is blank (e.g. using upload callback, like in devtools)
   config.lean = config.track && s.upgrade !== null ? s.upgrade === BooleanFlag.False : config.lean;
   config.upload = config.track && typeof config.upload === Constant.String && s.upload && s.upload.length > Constant.HTTPS.length ? s.upload : config.upload;
-  
+
   // Log page metadata as dimensions
   dimension.log(Dimension.UserAgent, ua);
   dimension.log(Dimension.PageTitle, title);
-  dimension.log(Dimension.Url, scrub.url(location.href));
+  dimension.log(Dimension.Url, scrub.url(location.href, !!electron));
   dimension.log(Dimension.Referrer, document.referrer);
   dimension.log(Dimension.TabId, tab());
   dimension.log(Dimension.PageLanguage, document.documentElement.lang);
   dimension.log(Dimension.DocumentDirection, document.dir);
   dimension.log(Dimension.DevicePixelRatio, `${window.devicePixelRatio}`);
-  
+  dimension.log(Dimension.Dob, u.dob.toString());
+  dimension.log(Dimension.CookieVersion, u.version.toString());
+
   // Capture additional metadata as metrics
   metric.max(Metric.ClientTimestamp, s.ts);
-  metric.max(Metric.Playback, BooleanFlag.False); 
+  metric.max(Metric.Playback, BooleanFlag.False);
+  metric.max(Metric.Electron, electron);
 
   // Capture navigator specific dimensions
   if (navigator) {
@@ -48,7 +52,7 @@ export function start(): void {
     metric.max(Metric.MaxTouchPoints, navigator.maxTouchPoints);
     metric.max(Metric.DeviceMemory, Math.round((<any>navigator).deviceMemory));
     userAgentData();
-  } 
+  }
 
   if (screen) {
     metric.max(Metric.ScreenWidth, Math.round(screen.width));
@@ -69,12 +73,12 @@ export function start(): void {
 function userAgentData(): void {
   let uaData = navigator["userAgentData"];
   if (uaData && uaData.getHighEntropyValues) {
-    uaData.getHighEntropyValues(["model","platform","platformVersion","uaFullVersion"]).then(ua => { 
-      dimension.log(Dimension.Platform, ua.platform); 
-      dimension.log(Dimension.PlatformVersion, ua.platformVersion); 
+    uaData.getHighEntropyValues(["model","platform","platformVersion","uaFullVersion"]).then(ua => {
+      dimension.log(Dimension.Platform, ua.platform);
+      dimension.log(Dimension.PlatformVersion, ua.platformVersion);
       ua.brands?.forEach(brand => { dimension.log(Dimension.Brand, brand.name + Constant.Tilde + brand.version); });
-      dimension.log(Dimension.Model, ua.model); 
-      metric.max(Metric.Mobile, ua.mobile ? BooleanFlag.True : BooleanFlag.False); 
+      dimension.log(Dimension.Model, ua.model);
+      metric.max(Metric.Mobile, ua.mobile ? BooleanFlag.True : BooleanFlag.False);
     });
   } else { dimension.log(Dimension.Platform, navigator.platform); }
 }
@@ -85,11 +89,16 @@ export function stop(): void {
 }
 
 export function metadata(cb: MetadataCallback, wait: boolean = true): void {
-  if (data && wait === false) {
+  let upgraded = config.lean ? BooleanFlag.False : BooleanFlag.True;
+  // if caller hasn't specified that they want to skip waiting for upgrade but we've already upgraded, we need to
+  // directly execute the callback rather than adding to our list as we only process callbacks at the moment
+  // we go through the upgrading flow.
+  if (data && (upgraded || wait === false)) {
     // Immediately invoke the callback if the caller explicitly doesn't want to wait for the upgrade confirmation
     cb(data, !config.lean);
+  } else {
+    callbacks.push({callback: cb, wait: wait });
   }
-  callbacks.push({callback: cb, wait: wait });
 }
 
 export function id(): string {
@@ -144,9 +153,13 @@ function track(u: User, consent: BooleanFlag = null): void {
   // Convert time precision into days to reduce number of bytes we have to write in a cookie
   // E.g. Math.ceil(1628735962643 / (24*60*60*1000)) => 18852 (days) => ejo in base36 (13 bytes => 3 bytes)
   let end = Math.ceil((Date.now() + (Setting.Expire * Time.Day))/Time.Day);
+  // If DOB is not set in the user object, use the date set in the config as a DOB
+  let dob = u.dob === 0 ? (config.dob === null ? 0 : config.dob) : u.dob;
+
   // To avoid cookie churn, write user id cookie only once every day
-  if (u.expiry === null || Math.abs(end - u.expiry) >= Setting.CookieInterval || u.consent !== consent) {
-    setCookie(Constant.CookieKey, [data.userId, Setting.CookieVersion, end.toString(36), consent].join(Constant.Pipe), Setting.Expire);
+  if (u.expiry === null || Math.abs(end - u.expiry) >= Setting.CookieInterval || u.consent !== consent || u.dob !== dob) {
+    let cookieParts = [data.userId, Setting.CookieVersion, end.toString(36), consent, dob];
+    setCookie(Constant.CookieKey, cookieParts.join(Constant.Pipe), Setting.Expire);
   }
 }
 
@@ -180,7 +193,7 @@ function num(string: string, base: number = 10): number {
 }
 
 function user(): User {
-  let output: User = { id: shortid(), expiry: null, consent: BooleanFlag.False };
+  let output: User = { id: shortid(), version: 0, expiry: null, consent: BooleanFlag.False, dob: 0 };
   let cookie = getCookie(Constant.CookieKey);
   if(cookie && cookie.length > 0) {
     // Splitting and looking up first part for forward compatibility, in case we wish to store additional information in a cookie
@@ -200,9 +213,11 @@ function user(): User {
     }
     // End code for backward compatibility
     // Read version information and timestamp from cookie, if available
+    if (parts.length > 1) { output.version = num(parts[1]); }
     if (parts.length > 2) { output.expiry = num(parts[2], 36); }
     // Check if we have explicit consent to track this user
     if (parts.length > 3 && num(parts[3]) === 1) { output.consent = BooleanFlag.True; }
+    if (parts.length > 4 && num(parts[1]) > 1) { output.dob = num(parts[4]); }
     // Set track configuration to true for this user if we have explicit consent, regardless of project setting
     config.track = config.track || output.consent === BooleanFlag.True;
     // Get user id from cookie only if we tracking is enabled, otherwise fallback to a random id
@@ -241,7 +256,7 @@ function setCookie(key: string, value: string, time: number): void {
           rootDomain = `.${hostname[i]}${rootDomain ? rootDomain : Constant.Empty}`;
           // We do not wish to attempt writing a cookie on the absolute last part of the domain, e.g. .com or .net.
           // So we start attempting after second-last part, e.g. .domain.com (PASS) or .co.uk (FAIL)
-          if (i < hostname.length - 1) { 
+          if (i < hostname.length - 1) {
             // Write the cookie on the current computed top level domain
             document.cookie = `${cookie}${Constant.Semicolon}${Constant.Domain}${rootDomain}`;
             // Once written, check if the cookie exists and its value matches exactly with what we intended to set

package/src/data/variable.ts

@@ -1,5 +1,6 @@
-import { Constant, Event, VariableData } from "@clarity-types/data";
+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;
@@ -13,10 +14,28 @@ export function set(variable: string, value: string | string[]): void {
     log(variable, values);
 }
 
-export function identify(userId: string, sessionId: string = null, pageId: string = null): void {
-    log(Constant.UserId, [userId]);
-    log(Constant.SessionId, [sessionId]);
-    log(Constant.PageId, [pageId]);
+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 {
@@ -44,3 +63,22 @@ export function reset(): void {
 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/interaction/click.ts

@@ -92,10 +92,10 @@ function text(element: Node): string {
         // Grab text using "textContent" for most HTMLElements, however, use "value" for HTMLInputElements and "alt" for HTMLImageElement.
         let t = element.textContent || (element as HTMLInputElement).value || (element as HTMLImageElement).alt;
         if (t) {
-            // Trim any spaces at the beginning or at the end of string
-            // Also, replace multiple occurrence of space characters with a single white space
+            // Replace multiple occurrence of space characters with a single white space
+            // Also, trim any spaces at the beginning or at the end of string
             // Finally, send only first few characters as specified by the Setting
-            output = t.trim().replace(/\s+/g, Constant.Space).substr(0, Setting.ClickText);
+            output = t.replace(/\s+/g, Constant.Space).trim().substr(0, Setting.ClickText);
         }
     }
     return output;

package/src/performance/blank.ts

@@ -0,0 +1,7 @@
+export * from "@src/insight/blank";
+
+export let keys = [];
+
+/* Intentionally blank module with empty code */
+export function hashText(): void {}
+export function trigger(): void {}

package/src/queue.ts

@@ -9,6 +9,8 @@ export function setup() {
     if (typeof w !== "undefined") {
         w[c] = function() {
             (w[c].q = w[c].q || []).push(arguments);
+            // if the start function was called, don't queue it and instead process the queue
+            arguments[0] === "start" && w[c].q.unshift(w[c].q.pop()) && process();
         };
     }
 }

package/types/core.d.ts

@@ -34,11 +34,12 @@ export const enum ExtractSource {
     Javascript = 0,
     Cookie = 1,
     Text = 2,
-    Fragment = 3
+    Fragment = 3,
+    Hash = 4
 }
 
 export const enum Type {
-    Array = 1, 
+    Array = 1,
     Object = 2,
     Simple = 3
 }
@@ -135,6 +136,7 @@ export interface Config {
     fallback?: string;
     upgrade?: (key: string) => void;
     action?: (key: string) => void;
+    dob?: number;
 }
 
 export const enum Constant {

package/types/data.d.ts

@@ -5,7 +5,7 @@ export type DecodedToken = (any | any[]);
 
 export type MetadataCallback = (data: Metadata, playback: boolean) => void;
 export interface MetadataCallbackOptions {
-    callback: MetadataCallback, 
+    callback: MetadataCallback,
     wait: boolean
 }
 
@@ -105,7 +105,8 @@ export const enum Metric {
     Iframed = 31,
     MaxTouchPoints = 32,
     HardwareConcurrency = 33,
-    DeviceMemory = 34
+    DeviceMemory = 34,
+    Electron = 35
 }
 
 export const enum Dimension {
@@ -136,7 +137,9 @@ export const enum Dimension {
     Brand = 24,
     Model = 25,
     DevicePixelRatio = 26,
-    ConnectionType = 27
+    ConnectionType = 27,
+    Dob = 28,
+    CookieVersion = 29
 }
 
 export const enum Check {
@@ -146,7 +149,8 @@ export const enum Check {
     Retry = 3,
     Bytes = 4,
     Collection = 5,
-    Server = 6
+    Server = 6,
+    Page = 7
 }
 
 export const enum Code {
@@ -190,7 +194,7 @@ export const enum IframeStatus {
 export const enum Setting {
     Expire = 365, // 1 Year
     SessionExpire = 1, // 1 Day
-    CookieVersion = 1, // Increment this version every time there's a cookie schema change
+    CookieVersion = 2, // Increment this version every time there's a cookie schema change
     SessionTimeout = 30 * Time.Minute, // 30 minutes
     CookieInterval = 1, // 1 Day
     PingInterval = 1 * Time.Minute, // 1 Minute
@@ -198,6 +202,7 @@ export const enum Setting {
     SummaryInterval = 100, // Same events within 100ms will be collapsed into single summary
     ClickText = 25, // Maximum number of characters to send as part of Click event's text field
     PayloadLimit = 128, // Do not allow more than specified payloads per page
+    PageLimit = 128, // Do not allow more than 128 pages in a session
     ShutdownLimit = 2 * Time.Hour, // Shutdown instrumentation after specified time
     RetryLimit = 1, // Maximum number of attempts to upload a payload before giving up
     PlaybackBytesLimit = 10 * 1024 * 1024, // 10MB
@@ -218,7 +223,7 @@ export const enum Setting {
     MinUploadDelay = 100, // Minimum time before we are ready to flush events to the server
     MaxUploadDelay = 30 * Time.Second, // Do flush out payload once every 30s,
     ExtractLimit = 10000, // Do not extract more than 10000 characters
-    ChecksumPrecision = 24, // n-bit integer to represent token hash 
+    ChecksumPrecision = 24, // n-bit integer to represent token hash
     UploadTimeout = 15000 // Timeout in ms for XHR requests
 }
 
@@ -249,6 +254,8 @@ export const enum Constant {
     Dropped = "*na*",
     Comma = ",",
     Dot = ".",
+    At = "@",
+    Asterix = "*",
     Semicolon = ";",
     Equals = "=",
     Path = ";path=/",
@@ -258,6 +265,7 @@ export const enum Constant {
     Top = "_top",
     String = "string",
     Number = "number",
+    Email = "email",
     CookieKey = "_clck", // Clarity Cookie Key
     SessionKey = "_clsk", // Clarity Session Key
     TabKey = "_cltk", // Clarity Tab Key
@@ -266,6 +274,8 @@ export const enum Constant {
     Upgrade = "UPGRADE",
     Action = "ACTION",
     Extract = "EXTRACT",
+    UserHint = "userHint",
+    UserType = "userType",
     UserId = "userId",
     SessionId = "sessionId",
     PageId = "pageId",
@@ -289,7 +299,10 @@ export const enum Constant {
     ConditionStart = "{",
     ConditionEnd = "}",
     Seperator = "<SEP>",
-    Timeout = "Timeout"
+    Timeout = "Timeout",
+    Bang = "!",
+    SHA256 = "SHA-256",
+    Electron = "Electron"
 }
 
 export const enum XMLReadyState {
@@ -331,8 +344,10 @@ export interface Session {
 
 export interface User {
     id: string;
+    version: number;
     expiry: number;
     consent: BooleanFlag;
+    dob: number;
 }
 
 export interface Envelope extends Metadata {
@@ -371,6 +386,13 @@ export interface BaselineData {
     activityTime: number;
 }
 
+export interface IdentityData {
+    userId: string;
+    userHint: string;
+    sessionId?: string;
+    pageId?: string;
+}
+
 export interface DimensionData {
     [key: number]: string[];
 }
@@ -409,7 +431,7 @@ export interface UpgradeData {
 }
 
 export interface ExtractData {
-    [key: number]: [number, string][]; // Array of [id, value] for every extracted data
+    [key: number]: { [subkey : number]: string }; // Array of { subkey: number } representing the extracted data
 }
 
 export interface UploadData {

package/types/index.d.ts

@@ -14,7 +14,7 @@ interface Clarity {
   consent: () => void;
   event: (name: string, value: string) => void;
   set: (variable: string, value: string | string[]) => void;
-  identify: (userId: string, sessionId?: string, pageId?: string) => void;
+  identify: (userId: string, sessionId?: string, pageId?: string, userHint?: string) => void;
   metadata: (callback: Data.MetadataCallback, wait?: boolean) => void;
 }