@openreplay/tracker 15.0.0 → 15.0.2

package/dist/types/main/app/index.d.ts

@@ -0,0 +1,322 @@
+import type { Options as WebworkerOptions } from '../../common/interaction.js';
+import AttributeSender from '../modules/attributeSender.js';
+import FeatureFlags from '../modules/featureFlags.js';
+import type { Options as NetworkOptions } from '../modules/network.js';
+import Logger, { ILogLevel } from './logger.js';
+import Message from './messages.gen.js';
+import Nodes from './nodes/index.js';
+import type { Options as ObserverOptions } from './observer/top_observer.js';
+import Observer from './observer/top_observer.js';
+import type { Options as SanitizerOptions } from './sanitizer.js';
+import Sanitizer from './sanitizer.js';
+import type { Options as SessOptions } from './session.js';
+import Session from './session.js';
+import Ticker from './ticker.js';
+import { MaintainerOptions } from './nodes/maintainer.js';
+export interface StartOptions {
+    userID?: string;
+    metadata?: Record<string, string>;
+    forceNew?: boolean;
+    sessionHash?: string;
+    assistOnly?: boolean;
+    /**
+     * @deprecated We strongly advise to use .start().then instead.
+     *
+     * This method is kept for snippet compatibility only
+     * */
+    startCallback?: (result: StartPromiseReturn) => void;
+}
+interface OnStartInfo {
+    sessionID: string;
+    sessionToken: string;
+    userUUID: string;
+}
+declare const CANCELED: "canceled";
+type SuccessfulStart = OnStartInfo & {
+    success: true;
+};
+type UnsuccessfulStart = {
+    reason: typeof CANCELED | string;
+    success: false;
+};
+declare const UnsuccessfulStart: (reason: string) => UnsuccessfulStart;
+declare const SuccessfulStart: (body: OnStartInfo) => SuccessfulStart;
+export type StartPromiseReturn = SuccessfulStart | UnsuccessfulStart;
+type StartCallback = (i: OnStartInfo) => void;
+type CommitCallback = (messages: Array<Message>) => void;
+declare enum ActivityState {
+    NotActive = 0,
+    Starting = 1,
+    Active = 2,
+    ColdStart = 3
+}
+type AppOptions = {
+    revID: string;
+    node_id: string;
+    session_reset_key: string;
+    session_token_key: string;
+    session_pageno_key: string;
+    session_tabid_key: string;
+    local_uuid_key: string;
+    ingestPoint: string;
+    resourceBaseHref: string | null;
+    __is_snippet: boolean;
+    __debug_report_edp: string | null;
+    __debug__?: ILogLevel;
+    /** @deprecated see canvas prop */
+    __save_canvas_locally?: boolean;
+    /** @deprecated see canvas prop */
+    fixedCanvasScaling?: boolean;
+    localStorage: Storage | null;
+    sessionStorage: Storage | null;
+    forceSingleTab?: boolean;
+    /** Sometimes helps to prevent session breaking due to dict reset */
+    disableStringDict?: boolean;
+    assistSocketHost?: string;
+    /** @deprecated see canvas prop */
+    disableCanvas?: boolean;
+    canvas: {
+        disableCanvas?: boolean;
+        /**
+         * If you expect HI-DPI users mostly, this will render canvas
+         * in 1:1 pixel ratio
+         * */
+        fixedCanvasScaling?: boolean;
+        __save_canvas_locally?: boolean;
+        /**
+         * Use with care since it hijacks one frame each time it captures
+         * snapshot for every canvas
+         * */
+        useAnimationFrame?: boolean;
+        /**
+         * Use webp unless it produces too big images
+         * @default webp
+         * */
+        fileExt?: 'webp' | 'png' | 'jpeg' | 'avif';
+    };
+    crossdomain?: {
+        /**
+         * @default false
+         * */
+        enabled?: boolean;
+        /**
+         * used to send message up, will be '*' by default
+         * (check your CSP settings)
+         * @default '*'
+         * */
+        parentDomain?: string;
+    };
+    network?: NetworkOptions;
+    /**
+     * use this flag to force angular detection to be offline
+     *
+     * basically goes around window.Zone api changes to mutation observer
+     * and event listeners
+     * */
+    forceNgOff?: boolean;
+    /**
+     * This option is used to change how tracker handles potentially detached nodes
+     *
+     * defaults here are tested and proven to be lightweight and easy on cpu
+     *
+     * consult the docs before changing it
+     * */
+    nodes?: {
+        maintainer: Partial<MaintainerOptions>;
+    };
+} & WebworkerOptions & SessOptions;
+export type Options = AppOptions & ObserverOptions & SanitizerOptions;
+export declare const DEFAULT_INGEST_POINT = "https://api.openreplay.com/ingest";
+export default class App {
+    private readonly signalError;
+    readonly insideIframe: boolean;
+    readonly nodes: Nodes;
+    readonly ticker: Ticker;
+    readonly projectKey: string;
+    readonly sanitizer: Sanitizer;
+    readonly debug: Logger;
+    readonly notify: Logger;
+    readonly session: Session;
+    readonly localStorage: Storage;
+    readonly sessionStorage: Storage;
+    private readonly messages;
+    /**
+     * we need 2 buffers, so we don't lose anything
+     * @read coldStart implementation
+     * */
+    private bufferedMessages1;
+    private readonly bufferedMessages2;
+    readonly observer: Observer;
+    private readonly startCallbacks;
+    private readonly stopCallbacks;
+    private readonly commitCallbacks;
+    readonly options: AppOptions;
+    readonly networkOptions?: NetworkOptions;
+    private readonly revID;
+    private activityState;
+    private readonly version;
+    private worker?;
+    attributeSender: AttributeSender;
+    featureFlags: FeatureFlags;
+    socketMode: boolean;
+    private compressionThreshold;
+    private readonly bc;
+    private readonly contextId;
+    private canvasRecorder;
+    private uxtManager;
+    private conditionsManager;
+    private readonly tagWatcher;
+    private canStart;
+    private rootId;
+    private pageFrames;
+    private frameOderNumber;
+    private features;
+    constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>, signalError: (error: string, apis: string[]) => void, insideIframe: boolean);
+    /** used by child iframes for crossdomain only */
+    parentActive: boolean;
+    checkStatus: () => boolean;
+    parentCrossDomainFrameListener: (event: MessageEvent) => void;
+    /**
+     * context ids for iframes,
+     * order is not so important as long as its consistent
+     * */
+    trackedFrames: string[];
+    crossDomainIframeListener: (event: MessageEvent) => void;
+    /**
+     * { command : [remaining iframes] }
+     * + order of commands
+     **/
+    pollingQueue: Record<string, any>;
+    private readonly addCommand;
+    bootChildrenFrames: () => Promise<void>;
+    killChildrenFrames: () => void;
+    signalIframeTracker: () => void;
+    startTimeout: ReturnType<typeof setTimeout> | null;
+    allowAppStart(): void;
+    private checkNodeId;
+    private initWorker;
+    private handleWorkerMsg;
+    private _debug;
+    send(message: Message, urgent?: boolean): void;
+    /**
+     * Normal workflow: add timestamp and tab data to batch, then commit it
+     * every ~30ms
+     * */
+    private _nCommit;
+    coldStartCommitN: number;
+    /**
+     * Cold start: add timestamp and tab data to both batches
+     * every 2nd tick, ~60ms
+     * this will make batches a bit larger and replay will work with bigger jumps every frame
+     * but in turn we don't overload batch writer on session start with 1000 batches
+     * */
+    private _cStartCommit;
+    private commit;
+    private postToWorker;
+    private delay;
+    timestamp(): number;
+    safe<T extends (this: any, ...args: any[]) => void>(fn: T): T;
+    attachCommitCallback(cb: CommitCallback): void;
+    attachStartCallback: (cb: StartCallback, useSafe?: boolean) => void;
+    attachStopCallback: (cb: () => any, useSafe?: boolean) => void;
+    attachEventListener: (target: EventTarget, type: string, listener: EventListener, useSafe?: boolean, useCapture?: boolean) => void;
+    checkRequiredVersion(version: string): boolean;
+    private getTrackerInfo;
+    getSessionInfo(): {
+        userUUID: string | null;
+        projectKey: string;
+        revID: string;
+        trackerVersion: string;
+        isSnippet: boolean;
+        sessionID: string | undefined;
+        metadata: Record<string, string>;
+        userID: string | null;
+        timestamp: number;
+        projectID?: string;
+    };
+    getSessionToken(): string | undefined;
+    getSessionID(): string | undefined;
+    getSessionURL(options?: {
+        withCurrentTime?: boolean;
+    }): string | undefined;
+    getHost(): string;
+    getProjectKey(): string;
+    getBaseHref(): string;
+    resolveResourceURL(resourceURL: string): string;
+    isServiceURL(url: string): boolean;
+    active(): boolean;
+    resetNextPageSession(flag: boolean): void;
+    coldInterval: ReturnType<typeof setInterval> | null;
+    orderNumber: number;
+    coldStartTs: number;
+    singleBuffer: boolean;
+    private checkSessionToken;
+    /**
+     * start buffering messages without starting the actual session, which gives
+     * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
+     * and we will then send buffered batch, so it won't get lost
+     * */
+    coldStart(startOpts?: StartOptions, conditional?: boolean): Promise<void>;
+    private setupConditionalStart;
+    onSessionSent: () => void;
+    /**
+     * Starts offline session recording
+     * @param {Object} startOpts - options for session start, same as .start()
+     * @param {Function} onSessionSent - callback that will be called once session is fully sent
+     * */
+    offlineRecording(startOpts: StartOptions | undefined, onSessionSent: () => void): {
+        saveBuffer: () => void;
+        getBuffer: () => Message[];
+        setBuffer: (buffer: Message[]) => void;
+    };
+    /**
+     * Saves the captured messages in localStorage (or whatever is used in its place)
+     *
+     * Then, when this.offlineRecording is called, it will preload this messages and clear the storage item
+     *
+     * Keeping the size of local storage reasonable is up to the end users of this library
+     * */
+    saveBuffer(): void;
+    /**
+     * @returns buffer with stored messages for offline recording
+     * */
+    getBuffer(): Message[];
+    /**
+     * Used to set a buffer with messages array
+     * */
+    setBuffer(buffer: Message[]): void;
+    /**
+     * Uploads the stored session buffer to backend
+     * @returns promise that resolves once messages are loaded, it has to be awaited
+     * so the session can be uploaded properly
+     * @resolve - if messages were loaded in service worker successfully
+     * @reject {string} - error message
+     * */
+    uploadOfflineRecording(): Promise<void>;
+    prevOpts: StartOptions;
+    private _start;
+    restartCanvasTracking: () => void;
+    flushBuffer: (buffer: Message[]) => Promise<unknown>;
+    onUxtCb: never[];
+    addOnUxtCb(cb: (id: number) => void): void;
+    getUxtId(): number | null;
+    waitStart(): Promise<unknown>;
+    waitStarted(): Promise<unknown>;
+    waitStatus(status: ActivityState): Promise<unknown>;
+    /**
+     * basically we ask other tabs during constructor
+     * and here we just apply 10ms delay just in case
+     * */
+    start(...args: Parameters<App['_start']>): Promise<StartPromiseReturn>;
+    forceFlushBatch(): void;
+    getTabId(): string;
+    clearBuffers(): void;
+    /**
+     * Creates a named hook that expects event name, data string and msg direction (up/down),
+     * it will skip any message bigger than 5 mb or event name bigger than 255 symbols
+     * @returns {(msgType: string, data: string, dir: "up" | "down") => void}
+     * */
+    trackWs(channelName: string): (msgType: string, data: string, dir: 'up' | 'down') => void;
+    stop(stopWorker?: boolean): void;
+}
+export {};

package/dist/types/main/app/logger.d.ts

@@ -0,0 +1,17 @@
+export declare const LogLevel: {
+    readonly Verbose: 5;
+    readonly Log: 4;
+    readonly Warnings: 3;
+    readonly Errors: 2;
+    readonly Silent: 0;
+};
+export type ILogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export default class Logger {
+    private readonly level;
+    constructor(debugLevel?: ILogLevel);
+    private readonly shouldLog;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}

package/dist/types/main/app/messages.gen.d.ts

@@ -0,0 +1,81 @@
+import * as Messages from '../../common/messages.gen.js';
+export { default, Type } from '../../common/messages.gen.js';
+export declare function Timestamp(timestamp: number): Messages.Timestamp;
+export declare function SetPageLocationDeprecated(url: string, referrer: string, navigationStart: number): Messages.SetPageLocationDeprecated;
+export declare function SetViewportSize(width: number, height: number): Messages.SetViewportSize;
+export declare function SetViewportScroll(x: number, y: number): Messages.SetViewportScroll;
+export declare function CreateDocument(): Messages.CreateDocument;
+export declare function CreateElementNode(id: number, parentID: number, index: number, tag: string, svg: boolean): Messages.CreateElementNode;
+export declare function CreateTextNode(id: number, parentID: number, index: number): Messages.CreateTextNode;
+export declare function MoveNode(id: number, parentID: number, index: number): Messages.MoveNode;
+export declare function RemoveNode(id: number): Messages.RemoveNode;
+export declare function SetNodeAttribute(id: number, name: string, value: string): Messages.SetNodeAttribute;
+export declare function RemoveNodeAttribute(id: number, name: string): Messages.RemoveNodeAttribute;
+export declare function SetNodeData(id: number, data: string): Messages.SetNodeData;
+export declare function SetNodeScroll(id: number, x: number, y: number): Messages.SetNodeScroll;
+export declare function SetInputTarget(id: number, label: string): Messages.SetInputTarget;
+export declare function SetInputValue(id: number, value: string, mask: number): Messages.SetInputValue;
+export declare function SetInputChecked(id: number, checked: boolean): Messages.SetInputChecked;
+export declare function MouseMove(x: number, y: number): Messages.MouseMove;
+export declare function NetworkRequestDeprecated(type: string, method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number): Messages.NetworkRequestDeprecated;
+export declare function ConsoleLog(level: string, value: string): Messages.ConsoleLog;
+export declare function PageLoadTiming(requestStart: number, responseStart: number, responseEnd: number, domContentLoadedEventStart: number, domContentLoadedEventEnd: number, loadEventStart: number, loadEventEnd: number, firstPaint: number, firstContentfulPaint: number): Messages.PageLoadTiming;
+export declare function PageRenderTiming(speedIndex: number, visuallyComplete: number, timeToInteractive: number): Messages.PageRenderTiming;
+export declare function CustomEvent(name: string, payload: string): Messages.CustomEvent;
+export declare function UserID(id: string): Messages.UserID;
+export declare function UserAnonymousID(id: string): Messages.UserAnonymousID;
+export declare function Metadata(key: string, value: string): Messages.Metadata;
+export declare function CSSInsertRule(id: number, rule: string, index: number): Messages.CSSInsertRule;
+export declare function CSSDeleteRule(id: number, index: number): Messages.CSSDeleteRule;
+export declare function Fetch(method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number): Messages.Fetch;
+export declare function Profiler(name: string, duration: number, args: string, result: string): Messages.Profiler;
+export declare function OTable(key: string, value: string): Messages.OTable;
+export declare function StateAction(type: string): Messages.StateAction;
+export declare function ReduxDeprecated(action: string, state: string, duration: number): Messages.ReduxDeprecated;
+export declare function Vuex(mutation: string, state: string): Messages.Vuex;
+export declare function MobX(type: string, payload: string): Messages.MobX;
+export declare function NgRx(action: string, state: string, duration: number): Messages.NgRx;
+export declare function GraphQLDeprecated(operationKind: string, operationName: string, variables: string, response: string, duration: number): Messages.GraphQLDeprecated;
+export declare function PerformanceTrack(frames: number, ticks: number, totalJSHeapSize: number, usedJSHeapSize: number): Messages.PerformanceTrack;
+export declare function StringDictDeprecated(key: number, value: string): Messages.StringDictDeprecated;
+export declare function SetNodeAttributeDictDeprecated(id: number, nameKey: number, valueKey: number): Messages.SetNodeAttributeDictDeprecated;
+export declare function StringDict(key: string, value: string): Messages.StringDict;
+export declare function SetNodeAttributeDict(id: number, name: string, value: string): Messages.SetNodeAttributeDict;
+export declare function ResourceTimingDeprecated(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string): Messages.ResourceTimingDeprecated;
+export declare function ConnectionInformation(downlink: number, type: string): Messages.ConnectionInformation;
+export declare function SetPageVisibility(hidden: boolean): Messages.SetPageVisibility;
+export declare function LoadFontFace(parentID: number, family: string, source: string, descriptors: string): Messages.LoadFontFace;
+export declare function SetNodeFocus(id: number): Messages.SetNodeFocus;
+export declare function LongTask(timestamp: number, duration: number, context: number, containerType: number, containerSrc: string, containerId: string, containerName: string): Messages.LongTask;
+export declare function SetNodeAttributeURLBased(id: number, name: string, value: string, baseURL: string): Messages.SetNodeAttributeURLBased;
+export declare function SetCSSDataURLBased(id: number, data: string, baseURL: string): Messages.SetCSSDataURLBased;
+export declare function TechnicalInfo(type: string, value: string): Messages.TechnicalInfo;
+export declare function CustomIssue(name: string, payload: string): Messages.CustomIssue;
+export declare function CSSInsertRuleURLBased(id: number, rule: string, index: number, baseURL: string): Messages.CSSInsertRuleURLBased;
+export declare function MouseClick(id: number, hesitationTime: number, label: string, selector: string, normalizedX: number, normalizedY: number): Messages.MouseClick;
+export declare function MouseClickDeprecated(id: number, hesitationTime: number, label: string, selector: string): Messages.MouseClickDeprecated;
+export declare function CreateIFrameDocument(frameID: number, id: number): Messages.CreateIFrameDocument;
+export declare function AdoptedSSReplaceURLBased(sheetID: number, text: string, baseURL: string): Messages.AdoptedSSReplaceURLBased;
+export declare function AdoptedSSInsertRuleURLBased(sheetID: number, rule: string, index: number, baseURL: string): Messages.AdoptedSSInsertRuleURLBased;
+export declare function AdoptedSSDeleteRule(sheetID: number, index: number): Messages.AdoptedSSDeleteRule;
+export declare function AdoptedSSAddOwner(sheetID: number, id: number): Messages.AdoptedSSAddOwner;
+export declare function AdoptedSSRemoveOwner(sheetID: number, id: number): Messages.AdoptedSSRemoveOwner;
+export declare function JSException(name: string, message: string, payload: string, metadata: string): Messages.JSException;
+export declare function Zustand(mutation: string, state: string): Messages.Zustand;
+export declare function BatchMetadata(version: number, pageNo: number, firstIndex: number, timestamp: number, location: string): Messages.BatchMetadata;
+export declare function PartitionedMessage(partNo: number, partTotal: number): Messages.PartitionedMessage;
+export declare function NetworkRequest(type: string, method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number, transferredBodySize: number): Messages.NetworkRequest;
+export declare function WSChannel(chType: string, channelName: string, data: string, timestamp: number, dir: string, messageType: string): Messages.WSChannel;
+export declare function InputChange(id: number, value: string, valueMasked: boolean, label: string, hesitationTime: number, inputDuration: number): Messages.InputChange;
+export declare function SelectionChange(selectionStart: number, selectionEnd: number, selection: string): Messages.SelectionChange;
+export declare function MouseThrashing(timestamp: number): Messages.MouseThrashing;
+export declare function UnbindNodes(totalRemovedPercent: number): Messages.UnbindNodes;
+export declare function ResourceTiming(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string, transferredSize: number, cached: boolean): Messages.ResourceTiming;
+export declare function TabChange(tabId: string): Messages.TabChange;
+export declare function TabData(tabId: string): Messages.TabData;
+export declare function CanvasNode(nodeId: string, timestamp: number): Messages.CanvasNode;
+export declare function TagTrigger(tagId: number): Messages.TagTrigger;
+export declare function Redux(action: string, state: string, duration: number, actionTime: number): Messages.Redux;
+export declare function SetPageLocation(url: string, referrer: string, navigationStart: number, documentTitle: string): Messages.SetPageLocation;
+export declare function GraphQL(operationKind: string, operationName: string, variables: string, response: string, duration: number): Messages.GraphQL;
+export declare function WebVitals(name: string, value: string): Messages.WebVitals;

package/dist/types/main/app/nodes/index.d.ts

@@ -0,0 +1,31 @@
+import { MaintainerOptions } from './maintainer.js';
+type NodeCallback = (node: Node, isStart: boolean) => void;
+export interface NodesOptions {
+    node_id: string;
+    forceNgOff: boolean;
+    maintainer?: Partial<MaintainerOptions>;
+}
+export default class Nodes {
+    private readonly nodes;
+    private totalNodeAmount;
+    private readonly nodeCallbacks;
+    private readonly elementListeners;
+    private nextNodeId;
+    private readonly node_id;
+    private readonly forceNgOff;
+    private readonly maintainer;
+    constructor(params: NodesOptions);
+    syntheticMode(frameOrder: number): void;
+    attachNodeCallback: (nodeCallback: NodeCallback) => number;
+    scanTree: (cb: (node: Node | void) => void) => void;
+    attachNodeListener: (node: Node, type: string, listener: EventListener, useCapture?: boolean) => void;
+    registerNode(node: Node): [/*id:*/ number, /*isNew:*/ boolean];
+    unregisterNode: (node: Node) => number | undefined;
+    cleanTree(): void;
+    callNodeCallbacks(node: Node, isStart: boolean): void;
+    getID(node: Node): number | undefined;
+    getNode(id: number): void | Node | undefined;
+    getNodeCount(): number;
+    clear(): void;
+}
+export {};

package/dist/types/main/app/nodes/maintainer.d.ts

@@ -0,0 +1,28 @@
+export interface MaintainerOptions {
+    /**
+     * Run cleanup each X ms
+     *
+     * @default 30 * 1000
+     * */
+    interval: number;
+    /**
+     * Maintainer checks nodes in small batches over 50ms timeouts
+     *
+     * @default 2500
+     * */
+    batchSize: number;
+    /**
+     * @default true
+     * */
+    enabled: boolean;
+}
+declare class Maintainer {
+    private readonly nodes;
+    private readonly unregisterNode;
+    private interval;
+    private readonly options;
+    constructor(nodes: Map<number, Node | void>, unregisterNode: (node: Node) => void, options?: Partial<MaintainerOptions>);
+    start: () => void;
+    stop: () => void;
+}
+export default Maintainer;

package/dist/types/main/app/observer/iframe_observer.d.ts

@@ -0,0 +1,6 @@
+import Observer from './observer.js';
+export default class IFrameObserver extends Observer {
+    docId: number | undefined;
+    observe(iframe: HTMLIFrameElement): void;
+    syntheticObserve(rootNodeId: number, doc: Document): void;
+}

package/dist/types/main/app/observer/iframe_offsets.d.ts

@@ -0,0 +1,8 @@
+export type Offset = [/*left:*/ number, /*top: */ number];
+export default class IFrameOffsets {
+    private states;
+    private calcOffset;
+    getDocumentOffset(doc: Document): Offset;
+    observe(iFrame: HTMLIFrameElement): void;
+    clear(): void;
+}

package/dist/types/main/app/observer/observer.d.ts

@@ -0,0 +1,29 @@
+import App from '../index.js';
+export default abstract class Observer {
+    protected readonly app: App;
+    protected readonly isTopContext: boolean;
+    private readonly observer;
+    private readonly commited;
+    private readonly recents;
+    private readonly indexes;
+    private readonly attributesMap;
+    private readonly textSet;
+    constructor(app: App, isTopContext?: boolean);
+    private clear;
+    /**
+     * EXPERIMENTAL: Unbinds the removed nodes in case of iframe src change.
+     *
+     * right now, we're relying on nodes.maintainer
+     */
+    private handleIframeSrcChange;
+    private sendNodeAttribute;
+    private sendNodeData;
+    private bindNode;
+    private bindTree;
+    private unbindTree;
+    private _commitNode;
+    private commitNode;
+    private commitNodes;
+    protected observeRoot(node: Node, beforeCommit: (id?: number) => unknown, nodeToBind?: Node): void;
+    disconnect(): void;
+}

package/dist/types/main/app/observer/shadow_root_observer.d.ts

@@ -0,0 +1,4 @@
+import Observer from './observer.js';
+export default class ShadowRootObserver extends Observer {
+    observe(el: Element): void;
+}

package/dist/types/main/app/observer/top_observer.d.ts

@@ -0,0 +1,31 @@
+import Observer from './observer.js';
+import { Offset } from './iframe_offsets.js';
+import App from '../index.js';
+export interface Options {
+    captureIFrames: boolean;
+}
+type Context = Window & typeof globalThis;
+type ContextCallback = (context: Context) => void;
+export default class TopObserver extends Observer {
+    private readonly options;
+    private readonly iframeOffsets;
+    readonly app: App;
+    constructor(params: {
+        app: App;
+        options: Partial<Options>;
+    });
+    private readonly contextCallbacks;
+    private readonly contextsSet;
+    attachContextCallback(cb: ContextCallback): void;
+    getDocumentOffset(doc: Document): Offset;
+    private iframeObserversArr;
+    private iframeObservers;
+    private docObservers;
+    private handleIframe;
+    private shadowRootObservers;
+    private handleShadowRoot;
+    observe(): void;
+    crossdomainObserve(rootNodeId: number, frameOder: number): void;
+    disconnect(): void;
+}
+export {};

package/dist/types/main/app/sanitizer.d.ts

@@ -0,0 +1,48 @@
+import type App from './index.js';
+export declare enum SanitizeLevel {
+    Plain = 0,
+    Obscured = 1,
+    Hidden = 2
+}
+export interface Options {
+    /**
+     * Sanitize emails in text DOM nodes
+     *
+     * (for inputs, look for obscureInputEmails)
+     * */
+    obscureTextEmails: boolean;
+    /**
+     * Sanitize emails in text DOM nodes
+     *
+     * (for inputs, look for obscureInputNumbers)
+     * */
+    obscureTextNumbers: boolean;
+    /**
+     * Sanitize the DOM node based on the returned level
+     * (Plain = 0, Obscured = 1, Hidden = 2)
+     *
+     * higher security levels will override other settings or data-params.
+     *
+     * @param node - the DOM node to sanitize
+     * @returns the level of sanitization to apply
+     *
+     * */
+    domSanitizer?: (node: Element) => SanitizeLevel;
+}
+export declare const stringWiper: (input: string) => string;
+export default class Sanitizer {
+    private readonly obscured;
+    private readonly hidden;
+    private readonly options;
+    private readonly app;
+    constructor(params: {
+        app: App;
+        options?: Partial<Options>;
+    });
+    handleNode(id: number, parentID: number, node: Node): void;
+    sanitize(id: number, data: string): string;
+    isObscured(id: number): boolean;
+    isHidden(id: number): boolean;
+    getInnerTextSecure(el: HTMLElement): string;
+    clear(): void;
+}

package/dist/types/main/app/session.d.ts

@@ -0,0 +1,57 @@
+import type App from './index.js';
+interface UserInfo {
+    userBrowser: string;
+    userCity: string;
+    userCountry: string;
+    userDevice: string;
+    userOS: string;
+    userState: string;
+}
+export interface SessionInfo {
+    sessionID: string | undefined;
+    metadata: Record<string, string>;
+    userID: string | null;
+    timestamp: number;
+    projectID?: string;
+}
+type OnUpdateCallback = (i: Partial<SessionInfo>) => void;
+export type Options = {
+    session_token_key: string;
+    session_pageno_key: string;
+    session_tabid_key: string;
+};
+export default class Session {
+    private metadata;
+    private userID;
+    private sessionID;
+    private readonly callbacks;
+    private timestamp;
+    private projectID;
+    private tabId;
+    userInfo: UserInfo;
+    private token;
+    private readonly app;
+    private readonly options;
+    constructor(params: {
+        app: App;
+        options: Options;
+    });
+    attachUpdateCallback(cb: OnUpdateCallback): void;
+    private handleUpdate;
+    assign(newInfo: Partial<SessionInfo>): void;
+    setMetadata(key: string, value: string): void;
+    setUserID(userID: string): void;
+    setUserInfo(userInfo: UserInfo): void;
+    getPageNumber: () => number | undefined;
+    incPageNo: () => number;
+    getSessionToken(): string | undefined;
+    setSessionToken(token: string): void;
+    applySessionHash(hash: string): void;
+    getSessionHash(): string | undefined;
+    getTabId(): string;
+    regenerateTabId(): void;
+    private createTabId;
+    getInfo(): SessionInfo;
+    reset(): void;
+}
+export {};