@oxvo/browser 7.1.0

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

@@ -0,0 +1,52 @@
+import Observer from './observer.js';
+import { Offset } from './iframe_offsets.js';
+import App from '../index.js';
+export declare enum InlineCssMode {
+    Unset = -1,
+    /** default behavior -- will parse and cache the css file on backend */
+    Disabled = 0,
+    /** will attempt to record the linked css file as AdoptedStyleSheet object */
+    Inline = 1,
+    /** will fetch the file, then simulate AdoptedStyleSheets behavior programmaticaly for the replay */
+    InlineFetched = 2,
+    /** will fetch the file, then save it as plain css inside <style> node */
+    PlainFetched = 3
+}
+export interface Options {
+    captureIFrames: boolean;
+    disableSprites: boolean;
+    /**
+     * with this option instead of using link element with href to load css,
+     * we will try to parse the css text instead and send it as css rules set
+     * can (and probably will) affect performance to certain degree,
+     * especially if the css itself is crossdomain
+     * @default InlineCssMode.None = 0
+     * */
+    inlineCss: InlineCssMode;
+    disableThrottling?: 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, frameLevel: number): void;
+    disconnect(): void;
+}
+export {};

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

@@ -0,0 +1,53 @@
+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 maskInputEmails)
+     * */
+    maskTextEmails: boolean;
+    /**
+     * Sanitize emails in text DOM nodes
+     *
+     * (for inputs, look for maskInputNumbers)
+     * */
+    maskTextNumbers: 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;
+    /**
+     * private by default mode that will mask all elements not marked by data-oxvosessions-unmask
+     * */
+    maskAllByDefault?: boolean;
+}
+export declare const stringWiper: (input: string) => string;
+export default class Sanitizer {
+    private readonly obscured;
+    private readonly hidden;
+    private readonly options;
+    readonly maskAllByDefault: boolean;
+    private readonly app;
+    constructor(params: {
+        app: App;
+        options?: Partial<Options>;
+    });
+    handleNode(id: number, parentID: number, node: Node): Set<number> | undefined;
+    sanitize(id: number, data: string): string;
+    isObscured(id: number): boolean;
+    isHidden(id: number): boolean;
+    getInnerTextSecure(el: HTMLElement): string;
+    clear(): void;
+}

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

@@ -0,0 +1,58 @@
+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;
+    getSessionSecret: (projectKey?: string) => string | undefined;
+    getRawSecretWithProject: () => string | null;
+    setSessionSecret: (token: string, projectKey: string) => void;
+    applySessionHash(hash: string): void;
+    getSessionHash(): string | undefined;
+    getTabId(): string;
+    regenerateTabId(): void;
+    private createTabId;
+    getInfo(): SessionInfo;
+    reset(): void;
+}
+export {};

package/dist/cjs/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/cjs/main/entry.d.ts

@@ -0,0 +1,6 @@
+import TrackerClass from './index';
+export { default as App } from './app/index';
+export { default as browser, default as oxvosessions } from './singleton';
+export { SanitizeLevel, Messages, Options } from './index';
+export { default as Analytics } from './modules/analytics/index';
+export default TrackerClass;

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

@@ -0,0 +1,119 @@
+import App from './app/index';
+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 AnalyticsSDK from './modules/analytics/index.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 { CssRulesOptions } from './modules/cssrules.js';
+import type { LATOptions } from './modules/longAnimationTask.js';
+import type { Options as WapOptions } from './modules/webAnimations.js';
+import type { Options as ViewportOptions } from './modules/viewport.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 & LATOptions> & {
+    siteKey: string;
+    sessionToken?: string;
+    honorDoNotTrack?: boolean;
+    autoResetOnWindowOpen?: boolean;
+    resetTabOnWindowOpen?: boolean;
+    networkCapture?: Partial<NetworkOptions>;
+    mouse?: Partial<MouseHandlerOptions>;
+    devAllowInsecure?: boolean;
+    css: CssRulesOptions;
+    webAnimations?: WapOptions;
+    urls?: Partial<ViewportOptions>;
+    analytics?: {
+        endpoint?: string;
+        active?: boolean;
+    };
+};
+export default class API {
+    readonly options: Partial<Options>;
+    private readonly app;
+    readonly analytics: AnalyticsSDK | null;
+    private readonly crossdomainMode;
+    private initBlockedReason;
+    constructor(options: Partial<Options>);
+    checkDoNotTrack: () => boolean | undefined;
+    signalStartIssue: (reason: string, missingApi: string[]) => void;
+    restartCanvasTracking: () => void;
+    use<T>(fn: (app: App | null, options?: Partial<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;
+    getSessionSecret(): string | null | undefined;
+    getSessionMeta(): SessionInfo | null;
+    getSessionKey(): string | null | undefined;
+    getTabId(): string | null;
+    getSessionLink: (options?: {
+        withCurrentTime?: boolean;
+    }) => string | undefined;
+    identify: (id: string, properties?: Record<string, any>) => void;
+    setVisitorID(id: string): void;
+    setMetadata(key: string, value: string): void;
+    track(key: string, payload?: any, issue?: boolean): void;
+    report(key: string, payload?: any): void;
+    handleError: (e: Error | ErrorEvent | PromiseRejectionEvent, metadata?: Record<string, any>) => void;
+    incident: (options: {
+        label?: string;
+        startTime: number;
+        endTime?: number;
+    }) => void;
+    private analyticsToken;
+    /**
+     * Use custom token for analytics events without session recording
+     * */
+    setAnalyticsToken: (token: string) => void;
+    getAnalyticsToken: () => string;
+}

package/dist/cjs/main/modules/analytics/batcher.d.ts

@@ -0,0 +1,45 @@
+interface PeopleEvent {
+    type: string;
+    timestamp: number;
+    payload: Record<string, any>;
+}
+interface Event {
+    name: string;
+    payload: Record<string, any>;
+    timestamp: number;
+}
+/**
+ * Creates batches of events, then sends them at intervals.
+ */
+declare class Batcher {
+    private readonly backendUrl;
+    private readonly getToken;
+    private readonly init;
+    private readonly autosendInterval;
+    private readonly retryTimeout;
+    private readonly retryLimit;
+    private readonly apiEdp;
+    private batch;
+    private intervalId;
+    constructor(backendUrl: string, getToken: () => string | null, init: () => Promise<void>);
+    getBatches(): {
+        data: {
+            user_actions: PeopleEvent[];
+            events: Event[];
+        };
+    };
+    addEvent(event: any): void;
+    sendImmediately(event: any): void;
+    /**
+     *
+     * Essentially we're dividing the batch by identify events and squash all same category events into one in each part,
+     * taking priority to the last one
+     */
+    dedupePeopleEvents(): PeopleEvent[];
+    private squashPeopleEvents;
+    private sendBatch;
+    startAutosend(): void;
+    flush(): void;
+    stop(): void;
+}
+export default Batcher;

package/dist/cjs/main/modules/analytics/constantProperties.d.ts

@@ -0,0 +1,53 @@
+export interface StorageLike {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+}
+export default class ConstantProperties {
+    private readonly localStorage;
+    private readonly sessionStorage;
+    os: string;
+    osVersion: string;
+    browser: string;
+    browserVersion: string;
+    platform: string;
+    screenHeight: number;
+    screenWidth: number;
+    initialReferrer: string;
+    utmSource: string | null;
+    utmMedium: string | null;
+    utmCampaign: string | null;
+    deviceId: string;
+    searchEngine: string | null;
+    user_id: string | null;
+    constructor(localStorage: StorageLike, sessionStorage: StorageLike);
+    get all(): {
+        os: string;
+        os_version: string;
+        browser: string;
+        browser_version: string;
+        platform: string;
+        screen_height: number;
+        screen_width: number;
+        initial_referrer: string;
+        utm_source: string | null;
+        utm_medium: string | null;
+        utm_campaign: string | null;
+        user_id: string | null;
+        distinct_id: string;
+        sdk_edition: string;
+        sdk_version: string;
+        timezone: string;
+        search_engine: string | null;
+    };
+    setUserId: (user_id: string | null) => void;
+    resetUserId: (hard?: boolean) => void;
+    get defaultPropertyKeys(): string[];
+    get distinctId(): string;
+    private getDistinctDeviceId;
+    private getReferrer;
+    private parseUTM;
+    private getSearchEngine;
+    getSuperProperties: () => Record<string, any>;
+    saveSuperProperties: (props: Record<string, any>) => void;
+    clearSuperProperties: () => void;
+}

package/dist/cjs/main/modules/analytics/events.d.ts

@@ -0,0 +1,37 @@
+import Batcher from './batcher.js';
+import ConstantProperties from './constantProperties.js';
+export default class Events {
+    private readonly constantProperties;
+    private readonly getTimestamp;
+    private readonly batcher;
+    ownProperties: Record<string, any>;
+    constructor(constantProperties: ConstantProperties, getTimestamp: () => number, batcher: Batcher);
+    /**
+     * Add event to batch with option to send it immediately,
+     * properties are optional and will not be saved as super prop
+     * */
+    sendEvent: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+    /**
+     * creates super property for all events
+     * */
+    setProperty: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    /**
+     * set super property only if it doesn't exist yet
+     * */
+    setPropertiesOnce: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    /**
+     * removes properties from list of super properties
+     * */
+    unsetProperties: (properties: string | string[]) => void;
+    /** clears all super properties */
+    reset: () => void;
+    /** mixpanel compatibility */
+    register: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    register_once: (nameOrProperties: Record<string, any> | string, value?: any) => void;
+    unregister: (properties: string | string[]) => void;
+    track: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+}

package/dist/cjs/main/modules/analytics/index.d.ts

@@ -0,0 +1,73 @@
+import ConstantProperties from './constantProperties.js';
+import type { StorageLike } from './constantProperties.js';
+import Events from './events.js';
+import People from './people.js';
+interface Options {
+    ingestPoint: string;
+    projectKey: string;
+    /** Storage class for persistent data */
+    localStorage?: StorageLike;
+    /** Storage class for data on a per-session basis */
+    sessionStorage?: StorageLike;
+    /** Used to request a custom session token when in not-standalone mode */
+    getToken?: () => string;
+    /** Used to get current timestamp when not in standalone mode */
+    getTimestamp?: () => number;
+    /** Callback for people.identify */
+    setUserId?: (user_id: string) => void;
+    /** automatically set when used inside oxvosessions tracker */
+    notStandalone?: boolean;
+}
+export default class Analytics {
+    readonly events: Events;
+    readonly constantProperties: ConstantProperties;
+    readonly people: People;
+    private token;
+    private readonly batcher;
+    private readonly backendUrl;
+    private readonly projectKey;
+    private readonly localStorage;
+    private readonly sessionStorage;
+    private readonly getToken;
+    private readonly getTimestamp;
+    private readonly setUserId;
+    private readonly standalone;
+    /**
+     * @param localStorage Class or Object that implements Storage-like interface that stores
+     * values persistently like window.localStorage or any other file-based storage
+     *
+     * @param sessionStorage Class or Object that implements Storage-like interface that stores values
+     * on per-session basis like window.sessionStorage or any other in-memory storage
+     *
+     * @param getToken Function that returns token to bind events to a session
+     *
+     * @param getTimestamp returns current timestamp
+     *
+     * @param setUserId callback for people.identify
+     *
+     * @param standalone if true, analytics will manage its own token (instead of using with oxvosessions tracker session)
+     * */
+    constructor(options: Options);
+    _getToken: () => string | null;
+    _getTimestamp: () => number;
+    init: () => Promise<void>;
+    reset: () => void;
+    /**
+     * COMPATIBILITY LAYER
+     * */
+    /**
+     * Identify a user with an id (e.g. email, username, etc.)
+     * will bind all events and properties (including device_id) to this user
+     *
+     * you will need to manually call people.reset() to clear the id on logout event
+     * */
+    identify: (user_id: string, properties?: Record<string, any>) => void;
+    /**
+     * Add event to batch with option to send it immediately,
+     * properties are optional and will not be saved as super prop
+     * */
+    track: (eventName: string, properties?: Record<string, any>, options?: {
+        send_immediately: boolean;
+    }) => void;
+}
+export {};

package/dist/cjs/main/modules/analytics/people.d.ts

@@ -0,0 +1,56 @@
+import Batcher from './batcher.js';
+import ConstantProperties from './constantProperties.js';
+type Value = string | number;
+export default class People {
+    private readonly constantProperties;
+    private readonly getTimestamp;
+    private readonly onId;
+    private readonly batcher;
+    ownProperties: Record<string, Value | Value[]>;
+    private readonly defaultPropertyKeyMap;
+    constructor(constantProperties: ConstantProperties, getTimestamp: () => number, onId: (user_id: string) => void, batcher: Batcher);
+    private normalizeUserPropertyKey;
+    private normalizeUserProperties;
+    identify: (user_id: string, propertiesOrOptions?: Record<string, any> | {
+        fromTracker?: boolean;
+    }, options?: {
+        fromTracker?: boolean;
+    }) => void;
+    /** Resets user id and own properties
+     *
+     * !hard reset will destroy persistent device id!
+     * */
+    reset: (hard?: boolean) => void;
+    get user_id(): string | null;
+    /**
+     *  Will delete user and its data from backend, then reset all local properties
+     */
+    deleteUser: () => void;
+    /**
+     * set user properties, overwriting existing ones
+     * */
+    setProperties: (propertyOrObj: Record<string, string | number> | string, value?: string) => void;
+    /**
+     * Set property if it doesn't exist yet
+     * */
+    setPropertiesOnce: (properties: Record<string, string | number>) => void;
+    /**
+     * Add value to property (will turn string prop into array)
+     * */
+    appendValues: (key: string, value: string | number) => void;
+    /**
+     * Add unique values to property (will turn string prop into array)
+     * */
+    appendUniqueValues: (key: string, value: string | number) => void;
+    /**
+     * Adds value (incl. negative) to existing numerical property
+     * */
+    increment: (key: string, value: number) => void;
+    /** mixpanel compatibility */
+    union: (key: string, value: string | number) => void;
+    set: (propertyOrObj: Record<string, string | number> | string, value?: string) => void;
+    set_once: (properties: Record<string, string | number>) => void;
+    append: (key: string, value: string | number) => void;
+    incrementBy: (key: string, value: number) => void;
+}
+export {};

package/dist/cjs/main/modules/analytics/types.d.ts

@@ -0,0 +1,32 @@
+export declare const mutationTypes: {
+    identity: string;
+    deleteUser: string;
+    setProperty: string;
+    setPropertyOnce: string;
+    appendProperty: string;
+    appendUniqueProperty: string;
+    incrementProperty: string;
+};
+export declare const categories: {
+    readonly people: "user_actions";
+    readonly events: "events";
+};
+export declare const createEvent: (category: (typeof categories)[keyof typeof categories], type?: (typeof mutationTypes)[keyof typeof mutationTypes], timestamp?: number, payload?: Record<string, any>) => {
+    category: "user_actions";
+    data: {
+        type: string | undefined;
+        user_id: any;
+        payload: any;
+        timestamp: number | undefined;
+        name?: undefined;
+    };
+} | {
+    category: "events";
+    data: {
+        name: any;
+        payload: any;
+        timestamp: number | undefined;
+        type?: undefined;
+        user_id?: undefined;
+    };
+};

package/dist/cjs/main/modules/analytics/utils.d.ts

@@ -0,0 +1,19 @@
+interface ClientData {
+    screen: string;
+    width: number;
+    height: number;
+    browser: string;
+    browserVersion: string;
+    browserMajorVersion: number;
+    mobile: boolean;
+    os: string;
+    osVersion: string;
+    cookies: boolean;
+}
+/**
+ * Detects client browser, OS, and device information
+ */
+export declare function uaParse(sWindow: Window & typeof globalThis): ClientData;
+export declare function isObject(item: any): boolean;
+export declare function getUTCOffsetString(): string;
+export {};

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

@@ -0,0 +1,22 @@
+import App from '../app/index.js';
+export declare class StringDictionary {
+    private lastTs;
+    private lastSuffix;
+    /** backwards dictionary of
+     * [repeated str:key]
+     * */
+    private backDict;
+    getKey: (str: string) => [number, 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;
+}