@oxvo/browser 7.1.0

package/dist/cjs/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 {
+    __oxvosessions_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/cjs/main/modules/conditionsManager.d.ts

@@ -0,0 +1,89 @@
+import Message, { CustomEvent, JSException, MouseClick, NetworkRequest, SetPageLocation } from '../../common/messages.gen.js';
+import App, { StartOptions } from '../app/index.js';
+export interface IFeatureFlag {
+    key: string;
+    is_persist: boolean;
+    value: string | boolean;
+    payload: string;
+}
+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/cjs/main/modules/connection.d.ts

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

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

@@ -0,0 +1,18 @@
+import type App from '../app/index.js';
+export interface CssRulesOptions {
+    /** turn this on if you have issues with emotionjs created styles */
+    scanInMemoryCSS?: boolean;
+    /** how often to scan tracked stylesheets (with "empty" rules) */
+    checkCssInterval?: number;
+    /**
+    Useful for cases where you expect limited amount of mutations
+  
+    i.e when sheets are hydrated on client after initial render.
+  
+    if you want to observe for x seconds, do (x*1000)/checkCssInterval = checkLimit
+  
+    applied to each stylesheet individually.
+    */
+    checkLimit?: number;
+}
+export default function (app: App, opts: CssRulesOptions): void;

package/dist/cjs/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 {
+    trackErrors: 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/cjs/main/modules/focus.d.ts

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

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

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

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

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

package/dist/cjs/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 maskTextNumbers)
+     * */
+    maskInputNumbers: boolean;
+    /**
+     * Sanitize emails from DOM input nodes.
+     *
+     * (for plain text nodes, look for maskTextEmails)
+     * */
+    maskInputEmails: boolean;
+    /**
+     * Sanitize dates from DOM input nodes.
+     * */
+    maskInputDates: boolean;
+    /**
+     * Default input mode for all input nodes. Higher security level
+     * will override other settings.
+     * */
+    inputPrivacyMode: InputModeT;
+}
+export default function (app: App, opts: Partial<Options>): void;
+export {};

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

@@ -0,0 +1,25 @@
+import type App from '../app/index.js';
+export interface LongAnimationTask extends PerformanceEntry {
+    name: string;
+    duration: number;
+    blockingDuration: number;
+    firstUIEventTimestamp: number;
+    startTime: number;
+    scripts: [
+        {
+            name: string;
+            duration: number;
+            invoker: string;
+            invokerType: string;
+            pauseDuration: number;
+            sourceURL: string;
+            sourceFunctionName: string;
+            sourceCharPosition: number;
+            forcedStyleAndLayoutDuration: number;
+        }
+    ];
+}
+export interface LATOptions {
+    longTasks: boolean;
+}
+export default function (app: App, opts: Partial<LATOptions>): void;

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

@@ -0,0 +1,25 @@
+export declare const WATCHED_MARKERS_KEY = "__or__watched_markers__";
+declare class MarkerWatcher {
+    interval: ReturnType<typeof setInterval> | null;
+    tags: {
+        id: number;
+        selector: string;
+    }[];
+    observer: IntersectionObserver;
+    private readonly sessionStorage;
+    private readonly errLog;
+    private readonly onMarkerHit;
+    constructor(params: {
+        sessionStorage: Storage;
+        errLog: (args: any[]) => void;
+        onMarkerHit: (markerId: number) => void;
+    });
+    fetchTags(ingest: string, token: string): Promise<void>;
+    setTags(tags: {
+        id: number;
+        selector: string;
+    }[]): void;
+    onMarkerRendered(markerId: number): void;
+    clear(): void;
+}
+export default MarkerWatcher;

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

@@ -0,0 +1,13 @@
+import type App from '../app/index.js';
+export interface MouseHandlerOptions {
+    disableClickmaps?: boolean;
+    /**
+     * how many ticks to wait before capturing mouse position
+     * (can affect performance)
+     * 1 tick = 30ms
+     * default 7 = 210ms
+     * */
+    trackingOffset?: number;
+}
+export default function (app: App, options?: MouseHandlerOptions): void;
+export declare function getCSSPath(el: any): string | false;

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

@@ -0,0 +1,32 @@
+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;
+    errorsOnly: boolean;
+    ignoreHeaders: Array<string> | boolean;
+    captureBodies: boolean;
+    captureInIframes: boolean;
+    sanitizer?: Sanitizer;
+    axiosInstances?: Array<AxiosInstance>;
+    useProxy?: boolean;
+    tokenUrlMatcher?: (url: string) => boolean;
+    enabled: boolean;
+}
+export default function (app: App, opts?: Partial<Options>): void;
+export {};

package/dist/cjs/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 {
+    trackPerformance: boolean;
+}
+export default function (app: App, opts: Partial<Options>): void;

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

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

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

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

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

@@ -0,0 +1,13 @@
+import type App from '../app/index.js';
+export interface Options {
+    urlSanitizer?: (url: string) => string;
+    titleSanitizer?: (title: string) => string;
+    /** if present, tracker will remove hash symbol to present url as regular router url on replay level;
+     *
+     * applied BEFORE sanitizers.
+     *
+     * @example 'site.com/#/path' -> 'site.com/path'
+     */
+    replaceHashSymbol?: boolean;
+}
+export default function (app: App, options?: Options): void;

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

@@ -0,0 +1,9 @@
+import type App from '../app/index.js';
+/**
+ * this will only work for custom elements by default (because of ionic)
+ */
+export interface Options {
+    allElements?: boolean;
+}
+declare function webAnimations(app: App, options?: Options): void;
+export default webAnimations;

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

@@ -0,0 +1,102 @@
+import Tracker, { App, Options } from './index.js';
+import type { StartOptions, StartPromiseReturn } from './app/index.js';
+declare class BrowserSingleton {
+    private instance;
+    private isConfigured;
+    /**
+     * Call this method once to create browser SDK configuration
+     * @param options {Object} Check available options:
+     * https://docs.oxvo.com/en/sdk/constructor/#initialization-options
+     */
+    configure(options: Partial<Options>): void;
+    get options(): Partial<Options> | null;
+    start(startOpts?: Partial<StartOptions>): Promise<StartPromiseReturn>;
+    /**
+     * Stop the session and return sessionHash
+     * (which can be used to stitch sessions together)
+     * */
+    stop(): string | undefined;
+    identify(id: string, properties?: Record<string, any>): void;
+    get analytics(): import("./entry.js").Analytics | null;
+    /**
+     * Set metadata for the current session
+     *
+     * Keys must be configured in project settings (metadata slots)
+     *
+     * Read more: https://docs.oxvo.com/en/installation/metadata/
+     */
+    setMetadata(key: string, value: string): void;
+    /**
+     * Returns full URL for the current session
+     */
+    getSessionLink(options?: {
+        withCurrentTime?: boolean;
+    }): string | undefined;
+    getSessionKey(): string | null | undefined;
+    getSessionSecret(): string | null | undefined;
+    track(key: string, payload?: any, issue?: boolean): void;
+    report(key: string, payload?: any): void;
+    handleError(e: Error | ErrorEvent | PromiseRejectionEvent, metadata?: Record<string, any>): void;
+    restartCanvasTracking(): void;
+    /**
+     * Set the anonymous user ID
+     */
+    setVisitorID(id: string): void;
+    /**
+     * Check if the browser SDK is active
+     */
+    isActive(): boolean;
+    /**
+     * Get the underlying browser SDK instance
+     *
+     * Use when you need access to methods not exposed by the singleton
+     */
+    getInstance(): Tracker | null;
+    /**
+     * 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;
+    /**
+     * 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;
+    private ensureConfigured;
+    use<T>(fn: (app: App | null, options?: Partial<Options>) => T): T;
+    /**
+     * 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(...args: Parameters<Tracker['startOfflineRecording']>): Promise<never> | {
+        saveBuffer: () => void;
+        getBuffer: () => import("./app/messages.gen.js").default[];
+        setBuffer: (buffer: import("./app/messages.gen.js").default[]) => void;
+    } | undefined;
+    /**
+     * 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;
+    forceFlushBatch(): void;
+    getSessionMeta(): import("./app/session.js").SessionInfo | null;
+    getTabId(): string | null;
+}
+declare const browser: BrowserSingleton;
+export default browser;

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

@@ -0,0 +1,35 @@
+export declare const IN_BROWSER: boolean;
+export declare const IS_FIREFOX: false | RegExpMatchArray | null;
+export declare const MAX_STR_LEN = 100000;
+export declare function adjustTimeOrigin(): void;
+export declare function getTimeOrigin(): number;
+export declare const now: () => number;
+export declare const stars: (str: string) => string;
+export declare function normSpaces(str: string): string;
+export declare function isURL(s: string): boolean;
+export declare const DOCS_HOST = "https://docs.oxvo.com";
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function canUseTrackerOrigin(protocol: string, hostname: string, devAllowInsecure?: boolean): boolean;
+export declare function deprecationWarn(nameOfFeature: string, useInstead: string, docsPath?: string): void;
+export declare function getLabelAttribute(e: Element): string | null;
+export declare function hasOxvoSessionsAttribute(e: Element, attr: string): boolean;
+/**
+ * checks if iframe is accessible
+ **/
+export declare function canAccessIframe(iframe: HTMLIFrameElement): boolean;
+export declare function canAccessTarget(target: EventTarget): boolean;
+export declare function generateRandomId(len?: number): string;
+export declare function inIframe(): boolean | null;
+/**
+ * Because angular devs decided that its a good idea to override a browser apis
+ * we need to use this to achieve safe behavior
+ * */
+export declare function ngSafeBrowserMethod(method: string): string;
+export declare function createMutationObserver(cb: MutationCallback, forceNgOff?: boolean): MutationObserver;
+export declare function createEventListener(target: EventTarget, event: string, cb: EventListenerOrEventListenerObject, capture?: boolean, forceNgOff?: boolean): void;
+export declare function deleteEventListener(target: EventTarget, event: string, cb: EventListenerOrEventListenerObject, capture?: boolean, forceNgOff?: boolean): void;
+export declare function requestIdleCb(callback: () => void): void;
+export declare function simpleMerge<T>(defaultObj: T, givenObj: Partial<T>): T;
+export declare function throttleWithTrailing<K, Args extends any[]>(fn: (key: K, ...args: Args) => void, interval: number): ((key: K, ...args: Args) => void) & {
+    clear: () => void;
+};

package/dist/lib/common/interaction.d.ts

@@ -0,0 +1,37 @@
+import Message from './messages.gen.js';
+export interface Options {
+    connAttemptCount?: number;
+    connAttemptGap?: number;
+}
+type Start = {
+    type: 'start';
+    ingestPoint: string;
+    pageNo: number;
+    timestamp: number;
+    url: string;
+    tabId: string;
+} & Options;
+type Auth = {
+    type: 'auth';
+    token: string;
+    beaconSizeLimit?: number;
+};
+export type ToWorkerData = null | 'stop' | Start | Auth | Array<Message> | {
+    type: 'compressed';
+    batch: Uint8Array;
+} | {
+    type: 'uncompressed';
+    batch: Uint8Array;
+} | 'forceFlushBatch' | 'closing' | 'check_queue';
+type Failure = {
+    type: 'failure';
+    reason: string;
+};
+type QEmpty = {
+    type: 'queue_empty';
+};
+export type FromWorkerData = 'a_stop' | 'a_start' | Failure | 'not_init' | {
+    type: 'compress';
+    batch: Uint8Array;
+} | QEmpty;
+export {};