@openreplay/tracker 15.0.0 → 15.0.2

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

@@ -0,0 +1,18 @@
+import App from './index.js';
+type Callback = () => void;
+export default class Ticker {
+    private readonly app;
+    private timer;
+    private readonly callbacks;
+    constructor(app: App);
+    /**
+     * @param {Callback} callback - repeated cb
+     * @param {number} n - number of turn skips; ticker have a 30 ms cycle
+     * @param {boolean} useSafe - using safe wrapper to check if app is active
+     * @param {object} thisArg - link to <this>
+     * */
+    attach(callback: Callback, n?: number, useSafe?: boolean, thisArg?: any): void;
+    start(): void;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,111 @@
+import App from './app/index.js';
+export { default as App } from './app/index.js';
+import * as _Messages from './app/messages.gen.js';
+export declare const Messages: typeof _Messages;
+export { SanitizeLevel } from './app/sanitizer.js';
+import FeatureFlags, { IFeatureFlag } from './modules/featureFlags.js';
+import type { Options as AppOptions } from './app/index.js';
+import type { Options as ConsoleOptions } from './modules/console.js';
+import type { Options as ExceptionOptions } from './modules/exception.js';
+import type { Options as InputOptions } from './modules/input.js';
+import type { Options as PerformanceOptions } from './modules/performance.js';
+import type { Options as TimingOptions } from './modules/timing.js';
+import type { Options as NetworkOptions } from './modules/network.js';
+import type { MouseHandlerOptions } from './modules/mouse.js';
+import type { SessionInfo } from './app/session.js';
+import type { StartOptions } from './app/index.js';
+import type { StartPromiseReturn } from './app/index.js';
+export type Options = Partial<AppOptions & ConsoleOptions & ExceptionOptions & InputOptions & PerformanceOptions & TimingOptions> & {
+    projectID?: number;
+    projectKey: string;
+    sessionToken?: string;
+    respectDoNotTrack?: boolean;
+    autoResetOnWindowOpen?: boolean;
+    resetTabOnWindowOpen?: boolean;
+    network?: Partial<NetworkOptions>;
+    mouse?: Partial<MouseHandlerOptions>;
+    flags?: {
+        onFlagsLoad?: (flags: IFeatureFlag[]) => void;
+    };
+    __DISABLE_SECURE_MODE?: boolean;
+};
+export default class API {
+    private readonly options;
+    featureFlags: FeatureFlags;
+    private readonly app;
+    private readonly crossdomainMode;
+    constructor(options: Options);
+    checkDoNotTrack: () => boolean | undefined;
+    signalStartIssue: (reason: string, missingApi: string[]) => void;
+    isFlagEnabled(flagName: string): boolean;
+    onFlagsLoad(callback: (flags: IFeatureFlag[]) => void): void;
+    clearPersistFlags(): void;
+    reloadFlags(): Promise<void> | undefined;
+    getFeatureFlag(flagName: string): IFeatureFlag | undefined;
+    getAllFeatureFlags(): IFeatureFlag[] | undefined;
+    restartCanvasTracking: () => void;
+    use<T>(fn: (app: App | null, options?: Options) => T): T;
+    isActive(): boolean;
+    /**
+     * 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
+     * msg direction is "down" (incoming) by default
+     *
+     * @returns {(msgType: string, data: string, dir: 'up' | 'down') => void}
+     * */
+    trackWs(channelName: string): ((msgType: string, data: string, dir: "up" | "down") => void) | undefined;
+    start(startOpts?: Partial<StartOptions>): Promise<StartPromiseReturn>;
+    browserEnvCheck(): boolean;
+    /**
+     * 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?: Partial<StartOptions>, conditional?: boolean): Promise<never> | undefined;
+    /**
+     * Starts offline session recording. Keep in mind that only user device time will be used for timestamps.
+     * (no backend delay sync)
+     *
+     * @param {Object} startOpts - options for session start, same as .start()
+     * @param {Function} onSessionSent - callback that will be called once session is fully sent
+     * @returns methods to manipulate buffer:
+     *
+     * saveBuffer - to save it in localStorage
+     *
+     * getBuffer - returns current buffer
+     *
+     * setBuffer - replaces current buffer with given
+     * */
+    startOfflineRecording(startOpts: Partial<StartOptions>, onSessionSent: () => void): Promise<never> | {
+        saveBuffer: () => void;
+        getBuffer: () => _Messages.default[];
+        setBuffer: (buffer: _Messages.default[]) => 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 into service worker successfully
+     * @reject {string} - error message
+     * */
+    uploadOfflineRecording(): Promise<void> | undefined;
+    stop(): string | undefined;
+    forceFlushBatch(): void;
+    getSessionToken(): string | null | undefined;
+    getSessionInfo(): SessionInfo | null;
+    getSessionID(): string | null | undefined;
+    getTabId(): string | null;
+    getUxId(): number | null;
+    sessionID(): string | null | undefined;
+    getSessionURL(options?: {
+        withCurrentTime?: boolean;
+    }): string | undefined;
+    setUserID(id: string): void;
+    userID(id: string): void;
+    setUserAnonymousID(id: string): void;
+    userAnonymousID(id: string): void;
+    setMetadata(key: string, value: string): void;
+    metadata(key: string, value: string): void;
+    event(key: string, payload?: any, issue?: boolean): void;
+    issue(key: string, payload?: any): void;
+    handleError: (e: Error | ErrorEvent | PromiseRejectionEvent, metadata?: Record<string, any>) => void;
+}

package/dist/types/main/modules/attributeSender.d.ts

@@ -0,0 +1,23 @@
+import App from '../app/index.js';
+export declare class StringDictionary {
+    private readonly getPageNo;
+    private idx;
+    /** backwards dictionary of
+     * [repeated str:key]
+     * */
+    private backDict;
+    constructor(getPageNo: () => number | undefined);
+    getKey: (str: string) => [string, boolean];
+}
+export default class AttributeSender {
+    private dict;
+    private readonly app;
+    private readonly isDictDisabled;
+    constructor(options: {
+        app: App;
+        isDictDisabled: boolean;
+    });
+    sendSetAttribute: (id: number, name: string, value: string) => void;
+    private applyDict;
+    clear(): void;
+}

package/dist/types/main/modules/axiosSpy.d.ts

@@ -0,0 +1,54 @@
+import type App from '../app/index.js';
+import type { RequestResponseData, Options } from './network.js';
+interface RawAxiosHeaders {
+    [key: string]: string;
+}
+interface AxiosRequestConfig {
+    url: string;
+    method?: string;
+    baseURL?: string;
+    status?: number;
+    headers: {
+        toJSON(): RawAxiosHeaders;
+    };
+    params?: any;
+    data?: any;
+}
+interface InternalAxiosRequestConfig extends AxiosRequestConfig {
+    __openreplay_timing: number;
+    headers: {
+        toJSON(): RawAxiosHeaders;
+        set(name: string, value: string): void;
+    };
+}
+interface AxiosResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: {
+        toJSON(): RawAxiosHeaders;
+    };
+    config: InternalAxiosRequestConfig;
+    request?: any;
+    response?: AxiosRequestConfig;
+}
+export interface AxiosInstance extends Record<string, any> {
+    getUri: (config?: AxiosRequestConfig) => string;
+    interceptors: {
+        request: AxiosInterceptorManager<InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+}
+export interface AxiosInterceptorOptions {
+    synchronous?: boolean;
+}
+export interface AxiosInterceptorManager<V> {
+    use(onFulfilled?: ((value: V) => V | Promise<V>) | null, onRejected?: ((error: any) => any) | null, options?: AxiosInterceptorOptions): number;
+    eject?: (id: number) => void;
+    clear?: () => void;
+}
+export default function (app: App, instance: AxiosInstance, opts: Options, sanitize: (data: RequestResponseData) => RequestResponseData | null, stringify: (data: {
+    headers: Record<string, string>;
+    body: any;
+}) => string): void;
+export {};

package/dist/types/main/modules/conditionsManager.d.ts

@@ -0,0 +1,84 @@
+import Message, { CustomEvent, JSException, MouseClick, NetworkRequest, SetPageLocation } from '../../common/messages.gen.js';
+import App, { StartOptions } from '../app/index.js';
+import { IFeatureFlag } from './featureFlags.js';
+interface Filter {
+    filters: {
+        operator: string;
+        value: string[];
+        type: string;
+        source?: string;
+    }[];
+    operator: string;
+    value: string[];
+    type: string;
+    source?: string;
+}
+export default class ConditionsManager {
+    private readonly app;
+    private readonly startParams;
+    conditions: Condition[];
+    hasStarted: boolean;
+    constructor(app: App, startParams: StartOptions);
+    setConditions(conditions: Condition[]): void;
+    fetchConditions(projectId: string, token: string): Promise<void>;
+    createConditionFromFilter: (filter: Filter) => Condition | undefined;
+    trigger(conditionName: string): void;
+    processMessage(message: Message): void;
+    processFlags(flag: IFeatureFlag[]): void;
+    durationInt: ReturnType<typeof setInterval> | null;
+    processDuration(durationMs: number, condName: string): void;
+    networkRequest(message: NetworkRequest): void;
+    customEvent(message: CustomEvent): void;
+    clickEvent(message: MouseClick): void;
+    pageLocationEvent(message: SetPageLocation): void;
+    jsExceptionEvent(message: JSException): void;
+}
+type CommonCondition = {
+    type: 'visited_url' | 'click' | 'custom_event';
+    operator: keyof typeof operators;
+    value: string[];
+    name: string;
+};
+type ExceptionCondition = {
+    type: 'exception';
+    operator: 'contains' | 'startsWith' | 'endsWith';
+    value: string[];
+    name: string;
+};
+type FeatureFlagCondition = {
+    type: 'feature_flag';
+    operator: 'is';
+    value: string[];
+    name: string;
+};
+type SessionDurationCondition = {
+    type: 'session_duration';
+    value: number[];
+    name: string;
+};
+type SubCondition = {
+    type: 'network_request';
+    key: 'url' | 'status' | 'method' | 'duration';
+    operator: keyof typeof operators;
+    value: string[];
+};
+type NetworkRequestCondition = {
+    type: 'network_request';
+    subConditions: SubCondition[];
+    name: string;
+};
+type Condition = CommonCondition | ExceptionCondition | FeatureFlagCondition | SessionDurationCondition | NetworkRequestCondition;
+declare const operators: {
+    is: (val: string, target: string[]) => boolean;
+    isAny: () => boolean;
+    isNot: (val: string, target: string[]) => boolean;
+    contains: (val: string, target: string[]) => boolean;
+    notContains: (val: string, target: string[]) => boolean;
+    startsWith: (val: string, target: string[]) => boolean;
+    endsWith: (val: string, target: string[]) => boolean;
+    greaterThan: (val: number, target: number) => boolean;
+    greaterOrEqual: (val: number, target: number) => boolean;
+    lessOrEqual: (val: number, target: number) => boolean;
+    lessThan: (val: number, target: number) => boolean;
+};
+export {};

package/dist/types/main/modules/connection.d.ts

@@ -0,0 +1,2 @@
+import App from '../app/index.js';
+export default function (app: App): void;

package/dist/types/main/modules/console.d.ts

@@ -0,0 +1,6 @@
+import type App from '../app/index.js';
+export interface Options {
+    consoleMethods: Array<string> | null;
+    consoleThrottling: number;
+}
+export default function (app: App, opts: Partial<Options>): void;

package/dist/types/main/modules/constructedStyleSheets.d.ts

@@ -0,0 +1,4 @@
+import type App from '../app/index.js';
+export declare function nextID(): number;
+export declare const styleSheetIDMap: Map<CSSStyleSheet, number>;
+export default function (app: App | null): void;

package/dist/types/main/modules/cssrules.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App | null): void;

package/dist/types/main/modules/exception.d.ts

@@ -0,0 +1,16 @@
+import type App from '../app/index.js';
+import type Message from '../app/messages.gen.js';
+export interface Options {
+    captureExceptions: boolean;
+}
+interface StackFrame {
+    columnNumber?: number;
+    lineNumber?: number;
+    fileName?: string;
+    functionName?: string;
+    source?: string;
+}
+export declare function getExceptionMessage(error: Error, fallbackStack: Array<StackFrame>, metadata?: Record<string, any>): Message;
+export declare function getExceptionMessageFromEvent(e: ErrorEvent | PromiseRejectionEvent, context?: typeof globalThis, metadata?: Record<string, any>): Message | null;
+export default function (app: App, opts: Partial<Options>): void;
+export {};

package/dist/types/main/modules/featureFlags.d.ts

@@ -0,0 +1,25 @@
+import App from '../app/index.js';
+export interface IFeatureFlag {
+    key: string;
+    is_persist: boolean;
+    value: string | boolean;
+    payload: string;
+}
+export interface FetchPersistFlagsData {
+    key: string;
+    value: string | boolean;
+}
+export default class FeatureFlags {
+    private readonly app;
+    flags: IFeatureFlag[];
+    storageKey: string;
+    onFlagsCb: (flags: IFeatureFlag[]) => void;
+    constructor(app: App);
+    getFeatureFlag(flagName: string): IFeatureFlag | undefined;
+    isFlagEnabled(flagName: string): boolean;
+    onFlagsLoad(cb: (flags: IFeatureFlag[]) => void): void;
+    reloadFlags(token?: string): Promise<void>;
+    handleFlags(flags: IFeatureFlag[]): void;
+    clearPersistFlags(): void;
+    diffPersist(flags: IFeatureFlag[]): IFeatureFlag[];
+}

package/dist/types/main/modules/focus.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/dist/types/main/modules/fonts.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/dist/types/main/modules/img.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/dist/types/main/modules/input.d.ts

@@ -0,0 +1,34 @@
+import type App from '../app/index.js';
+type TextFieldElement = HTMLInputElement | HTMLTextAreaElement;
+export declare function getInputLabel(node: TextFieldElement): string;
+export declare const InputMode: {
+    readonly Plain: 0;
+    readonly Obscured: 1;
+    readonly Hidden: 2;
+};
+export type InputModeT = (typeof InputMode)[keyof typeof InputMode];
+export interface Options {
+    /**
+     * Sanitize numbers from DOM input nodes.
+     *
+     * (for plain text nodes, look for obscureTextNumbers)
+     * */
+    obscureInputNumbers: boolean;
+    /**
+     * Sanitize emails from DOM input nodes.
+     *
+     * (for plain text nodes, look for obscureTextEmails)
+     * */
+    obscureInputEmails: boolean;
+    /**
+     * Sanitize dates from DOM input nodes.
+     * */
+    obscureInputDates: boolean;
+    /**
+     * Default input mode for all input nodes. Higher security level
+     * will override other settings.
+     * */
+    defaultInputMode: InputModeT;
+}
+export default function (app: App, opts: Partial<Options>): void;
+export {};

package/dist/types/main/modules/mouse.d.ts

@@ -0,0 +1,31 @@
+import type App from '../app/index.js';
+export interface MouseHandlerOptions {
+    disableClickmaps?: boolean;
+    /** minimum length of an optimised selector.
+     *
+     * body > div > div > p => body > p for example
+     *
+     * default 2
+     * */
+    minSelectorDepth?: number;
+    /** how many selectors to try before falling back to nth-child selectors
+     * performance expensive operation
+     *
+     * default 1000
+     * */
+    nthThreshold?: number;
+    /**
+     * how many tries to optimise and shorten the selector
+     *
+     * default 10_000
+     * */
+    maxOptimiseTries?: number;
+    /**
+     * how many ticks to wait before capturing mouse position
+     * (can affect performance)
+     * 1 tick = 30ms
+     * default 7
+     * */
+    trackingOffset?: number;
+}
+export default function (app: App, options?: MouseHandlerOptions): void;

package/dist/types/main/modules/network.d.ts

@@ -0,0 +1,31 @@
+import type App from '../app/index.js';
+import type { AxiosInstance } from './axiosSpy.js';
+interface RequestData {
+    body: string | null;
+    headers: Record<string, string>;
+}
+interface ResponseData {
+    body: any;
+    headers: Record<string, string>;
+}
+export interface RequestResponseData {
+    readonly status: number;
+    readonly method: string;
+    url: string;
+    request: RequestData;
+    response: ResponseData;
+}
+type Sanitizer = (data: RequestResponseData) => RequestResponseData | null;
+export interface Options {
+    sessionTokenHeader: string | boolean;
+    failuresOnly: boolean;
+    ignoreHeaders: Array<string> | boolean;
+    capturePayload: boolean;
+    captureInIframes: boolean;
+    sanitizer?: Sanitizer;
+    axiosInstances?: Array<AxiosInstance>;
+    useProxy?: boolean;
+    tokenUrlMatcher?: (url: string) => boolean;
+}
+export default function (app: App, opts?: Partial<Options>): void;
+export {};

package/dist/types/main/modules/performance.d.ts

@@ -0,0 +1,7 @@
+import type App from '../app/index.js';
+export declare const deviceMemory: number;
+export declare const jsHeapSizeLimit: number;
+export interface Options {
+    capturePerformance: boolean;
+}
+export default function (app: App, opts: Partial<Options>): void;

package/dist/types/main/modules/scroll.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App, insideIframe: boolean | null): void;

package/dist/types/main/modules/selection.d.ts

@@ -0,0 +1,7 @@
+import type App from '../app/index.js';
+declare function selection(app: App): void;
+export default selection;
+/** TODO: research how to get all in-between nodes inside selection range
+ *        including nodes between anchor and focus nodes and their children
+ *        without recursively searching the dom tree
+ */

package/dist/types/main/modules/tabs.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/dist/types/main/modules/tagWatcher.d.ts

@@ -0,0 +1,25 @@
+export declare const WATCHED_TAGS_KEY = "__or__watched_tags__";
+declare class TagWatcher {
+    intervals: Record<string, ReturnType<typeof setInterval>>;
+    tags: {
+        id: number;
+        selector: string;
+    }[];
+    observer: IntersectionObserver;
+    private readonly sessionStorage;
+    private readonly errLog;
+    private readonly onTag;
+    constructor(params: {
+        sessionStorage: Storage;
+        errLog: (args: any[]) => void;
+        onTag: (tag: number) => void;
+    });
+    fetchTags(ingest: string, token: string): Promise<void>;
+    setTags(tags: {
+        id: number;
+        selector: string;
+    }[]): void;
+    onTagRendered(tagId: number): void;
+    clear(): void;
+}
+export default TagWatcher;

package/dist/types/main/modules/timing.d.ts

@@ -0,0 +1,8 @@
+import type App from '../app/index.js';
+export interface Options {
+    captureResourceTimings: boolean;
+    capturePageLoadTimings: boolean;
+    capturePageRenderTimings: boolean;
+    excludedResourceUrls?: Array<string>;
+}
+export default function (app: App, opts: Partial<Options>): void;

package/dist/types/main/modules/userTesting/SignalManager.d.ts

@@ -0,0 +1,29 @@
+export default class SignalManager {
+    private readonly ingestPoint;
+    private readonly getTimestamp;
+    private readonly token;
+    private readonly testId;
+    private readonly storageKey;
+    private readonly setStorageKey;
+    private readonly removeStorageKey;
+    private readonly getStorageKey;
+    private readonly getSessionId;
+    private readonly durations;
+    constructor(ingestPoint: string, getTimestamp: () => number, token: string, testId: number, storageKey: string, setStorageKey: (key: string, value: string) => void, removeStorageKey: (key: string) => void, getStorageKey: (key: string) => string | null, getSessionId: () => string | undefined);
+    getDurations: () => {
+        testStart: number;
+        tasks: {
+            taskId: number;
+            started: number;
+        }[];
+    };
+    setDurations: (durations: {
+        testStart: number;
+        tasks: {
+            taskId: number;
+            started: number;
+        }[];
+    }) => void;
+    signalTask: (taskId: number, status: "begin" | "done" | "skipped", taskAnswer?: string) => void | Promise<Response>;
+    signalTest: (status: "begin" | "done" | "skipped") => Promise<Response>;
+}

package/dist/types/main/modules/userTesting/dnd.d.ts

@@ -0,0 +1 @@
+export default function attachDND(element: any, dragTarget: any): void;

package/dist/types/main/modules/userTesting/index.d.ts

@@ -0,0 +1,45 @@
+import App from '../../app/index.js';
+export default class UserTestManager {
+    private readonly app;
+    private readonly storageKey;
+    private readonly userRecorder;
+    private readonly bg;
+    private readonly container;
+    private widgetGuidelinesVisible;
+    private widgetTasksVisible;
+    private widgetVisible;
+    isActive: boolean;
+    private descriptionSection;
+    private taskSection;
+    private endSection;
+    private stopButton;
+    private stopButtonContainer;
+    private test;
+    private testId;
+    private signalManager;
+    constructor(app: App, storageKey: string);
+    getTestId(): number | null;
+    getTest: (id: number, token: string, inProgress?: boolean) => Promise<number | void>;
+    hideTaskSection: () => boolean;
+    showTaskSection: () => boolean;
+    collapseWidget: () => boolean;
+    removeGreeting: () => boolean;
+    createGreeting(title: string, micRequired: boolean, cameraRequired: boolean): void;
+    showWidget(guidelines: string, tasks: {
+        title: string;
+        description: string;
+        task_id: number;
+        allow_typing: boolean;
+    }[], inProgress?: boolean): void;
+    createTitleSection(): HTMLElement;
+    toggleDescriptionVisibility: () => void;
+    createDescriptionSection(guidelines: string): HTMLElement;
+    currentTaskIndex: number;
+    createTasksSection(tasks: {
+        title: string;
+        description: string;
+        task_id: number;
+        allow_typing: boolean;
+    }[]): HTMLElement;
+    showEndSection(): void;
+}

package/dist/types/main/modules/userTesting/recorder.d.ts

@@ -0,0 +1,24 @@
+import App from '../../app/index.js';
+export declare const Quality: {
+    Standard: {
+        width: number;
+        height: number;
+    };
+    High: {
+        width: number;
+        height: number;
+    };
+};
+export default class Recorder {
+    private readonly app;
+    private mediaRecorder;
+    private recordedChunks;
+    private stream;
+    private recStartTs;
+    constructor(app: App);
+    startRecording(fps: number, quality: (typeof Quality)[keyof typeof Quality], micReq: boolean, camReq: boolean): Promise<void>;
+    stopRecording(): Promise<Blob>;
+    sendToAPI(): Promise<void | Response>;
+    saveToFile(fileName?: string): Promise<void>;
+    discard(): void;
+}