ci-trap-web/dist/trap.d.ts

Lightweight mouse and touch event tracker library for browsers.

declare class Buffer {
    _enabled: boolean;
    _buffer: any[];
    _headerItems: any[];
    _bufferSizeLimit: number;
    _bufferTimeout: number;
    _bufferTimer: number;
    _idleTimeout: number;
    _idleTimer: number;
    _inactiveTimeout: number;
    _inactiveTimer: number;
    _inactive: boolean;
    set bufferSizeLimit(bufferSizeLimit: any);
    set bufferTimeout(bufferTimeout: any);
    clearBufferTimer(): void;
    setBufferTimer(): void;
    set idleTimeout(idleTimeout: any);
    set inactiveTimeout(inactiveTimeout: any);
    clearIdleTimer(): void;
    setIdleTimer(): void;
    setInactiveTimer(): void;
    clearInactiveTimer(): void;
    push(type: any, timestamp: any, ...props: any[]): void;
    addHeaderItem(...props: any[]): void;
    flush(): any[];
    isEmpty(): boolean;
    bufferInactive(): any;
    bufferActive(): any;
    requestSubmission(final: any): any;
    enable(): void;
    disable(): void;
    collectedEvents(): any;
}

declare class Metadata {
    _sessionId: any;
    _customMetadata: {};
    _apiKeyName: string;
    _apiKeyValue: string;
    _metadataSubmissionInterval: number;
    _collectUrls: boolean;
    _components: {
        name: string;
        version: string;
        type: string;
    }[];
    get sessionId(): any;
    get streamId(): any;
    set apiKeyName(apiKeyName: string);
    get apiKeyName(): string;
    set apiKeyValue(apiKeyValue: string);
    get apiKeyValue(): string;
    set metadataSubmissionInterval(metadataSubmissionInterval: number);
    get metadataSubmissionInterval(): number;
    _submissionTimer: number;
    set collectUrls(collectUrls: boolean);
    get collectUrls(): boolean;
    set components(components: any);
    get schema(): {
        version: string;
        components: {
            name: string;
            version: string;
            type: string;
        }[];
    };
    enable(): void;
    disable(): void;
    submit(): void;
    reset(): void;
    generateNewStreamId(): void;
    _streamId: any;
    serializeMetadata(): (number | {
        platform: {
            description: any;
            layout: any;
            manufacturer: any;
            name: any;
            prerelease: any;
            product: any;
            ua: any;
            version: any;
            os: {
                architecture: any;
                family: any;
                version: any;
            };
        };
        location: {
            current: string;
            previous: string;
        } | {
            current?: undefined;
            previous?: undefined;
        };
        custom: any;
        screen: {
            availHeight: number;
            availWidth: number;
            availLeft: any;
            availTop: any;
            height: number;
            width: number;
            top: any;
            left: any;
            colorDepth: number;
            pixelDepth: number;
            devicePixelRatio: number;
            orientation: {
                type: string;
                angle: number;
            };
        };
        document: {
            scrollLeft: number;
            scrollTop: number;
            scrollHeight: number;
            scrollWidth: number;
            offsetHeight: number;
            offsetWidth: number;
            clientTop: number;
            clientLeft: number;
            clientHeight: number;
            clientWidth: number;
        };
    })[];
    set(key: any, value: any): void;
    remove(key: any): void;
    get custom(): any;
    get platform(): {
        description: any;
        layout: any;
        manufacturer: any;
        name: any;
        prerelease: any;
        product: any;
        ua: any;
        version: any;
        os: {
            architecture: any;
            family: any;
            version: any;
        };
    };
    get location(): {
        current: string;
        previous: string;
    } | {
        current?: undefined;
        previous?: undefined;
    };
    get screen(): {
        availHeight: number;
        availWidth: number;
        availLeft: any;
        availTop: any;
        height: number;
        width: number;
        top: any;
        left: any;
        colorDepth: number;
        pixelDepth: number;
        devicePixelRatio: number;
        orientation: {
            type: string;
            angle: number;
        };
    };
    get orientation(): {
        type: string;
        angle: number;
    };
    get document(): {
        scrollLeft: number;
        scrollTop: number;
        scrollHeight: number;
        scrollWidth: number;
        offsetHeight: number;
        offsetWidth: number;
        clientTop: number;
        clientLeft: number;
        clientHeight: number;
        clientWidth: number;
    };
}

declare class Handlers {
    _registeredElements: any[];
    _captureCoalescedEvents: boolean;
    _requestAnimationFrameId: number;
    mountGlobal(): void;
    umountGlobal(): void;
    mount(element: any): void;
    umount(element: any): void;
    push(...props: any[]): void;
    requestSubmission(): void;
    captureCoalescedEvents(value: any): void;
    handlePointerMove(event: any): void;
    handleSinglePointerMove(event: any, coalesced: any): void;
    handlePointerDown(event: any): void;
    handlePointerUp(event: any): void;
    handleMouseMove(event: any, coalesced: any): void;
    handleMouseDown(event: any): void;
    handleMouseUp(event: any): void;
    handleTouchStart(event: any): void;
    handleTouchMove(event: any): void;
    handleTouchEnd(event: any): void;
    iterateTouches(event: any, fn: any): void;
    handleWheel(event: any): void;
    handleScroll(event: any): void;
    handleVisibilityChange(): void;
    handlePageHide(): void;
    handleFreeze(): void;
    handleBlur(event: any): void;
    handleFocus(event: any): void;
    startRequestAnimationFrame(): void;
    stopRequestAnimationFrame(): void;
    onRequestAnimationFrame(timeStamp: any): void;
}

declare class Transport {
    constructor(metadata: any);
    _metadata: any;
    _enableCompression: boolean;
    _url: URL;
    set url(url: any);
    createUrl(url: any): URL;
    submit(buffer: any): Promise<void>;
}

declare class HTTP extends Transport {
    set enableCompression(enableCompression: any);
    close(): void;
}

declare class InMemoryEventStorage {
    _inMemoryEventStorage: any[];
    _sizeLimit: number;
    set sizeLimit(sizeLimit: number);
    get sizeLimit(): number;
    set inMemoryEventStorage(inMemoryEventStorage: any[]);
    get inMemoryEventStorage(): any[];
    onDataSubmitted(data: any): void;
    flushStorage(): any[];
    cleanUpInMemoryBufferIfNeeded(): void;
    eventCount(): any;
    collectedEvents(): any;
}

/**
 * Singleton instance of Trap
 *
 * @type {Trap}
 */
declare const instance: Trap;
/**
 * Trap class for managing the data collection
 *
 * @class Trap
 */
declare class Trap {
    _buffer: Buffer;
    _metadata: Metadata;
    _handlers: Handlers;
    state: {
        logger: (...m: any[]) => void;
        transport: HTTP;
        sequenceNumber: number;
        eventStorage: InMemoryEventStorage;
        collectEvents: boolean;
        captureRequestAnimationFrame: boolean;
        onDataSubmittedCallback: any;
        restartOnBecomingActive: boolean;
        isRunning: boolean;
        stopDataCollectionOnPageHide: boolean;
    };
    /**
     * `streamId` getter
     *
     * @returns {string}
     */
    streamId(): string;
    /**
     * `sessionId` getter
     *
     * @returns {string}
     */
    sessionId(): string;
    /**
     * Set API key header name
     *
     * @param {string} apiKeyName
     */
    apiKeyName(apiKeyName: string): void;
    /**
     * Set API key value that is used to identify the integrator
     * organization/person who uses the data collection library.
     *
     * @param {string} apiKeyValue
     */
    apiKeyValue(apiKeyValue: string): void;
    /**
     * Deprecated alias of `apiKeyValue` setter
     * @deprecated use apiKeyValue instead
     *
     * @param {string} apiKeyValue
     */
    apiKey(apiKeyValue: string): void;
    /**
     * Set the appVersion property
     *
     * @param {Array<{
     *  name: string,
     *  version: string,
     *  type: 'library'|'application'
     * }>} components
     */
    components(components: Array<{
        name: string;
        version: string;
        type: 'library' | 'application';
    }>): void;
    /**
     * Mount Trap to a DOM element
     *
     * @param {EventTarget} element
     */
    mount(element: EventTarget): void;
    /**
     * Umount Trap from a DOM element
     *
     * @param {EventTarget} element
     */
    umount(element: EventTarget): void;
    /**
     * Set Buffer's idleTimeout
     *
     * @param {number} idleTimeout
     */
    idleTimeout(idleTimeout: number): void;
    /**
     * Set Buffer's inactiveTimeout
     *
     * @param {number} inactiveTimeout
     */
    inactiveTimeout(inactiveTimeout: number): void;
    /**
     * Enable/start data collection
     */
    start(): void;
    /**
     * Disable/stop data collection
     */
    stop(): void;
    /**
     * `bufferSizeLimit` setter proxy
     *
     * @param {number} bufferSizeLimit
     */
    bufferSizeLimit(bufferSizeLimit: number): void;
    /**
     * `bufferTimeout` setter proxy
     *
     * @param {number} bufferTimeout
     */
    bufferTimeout(bufferTimeout: number): void;
    /**
     * `enableCompression` setter proxy
     *
     * @param {boolean} enableCompression
     */
    enableCompression(enableCompression: boolean): void;
    /**
     * Remote Trap server URL setter
     *
     * @param {string} url
     */
    url(url: string): void;
    /**
     * Inject and later send custom event to stream
     *
     * @param {string|object} props
     */
    send(props: string | object): void;
    /**
     * Add message to buffer
     * @private
     *
     * @param {*} message
     */
    private pushMessage;
    /**
     * Submit data manually
     *
     * @param {boolean} final
     * @returns {Promise<void>}
     */
    submit(final: boolean): Promise<void>;
    /**
     * Add the header message to the buffer
     * @private
     */
    private addHeaderToBuffer;
    /**
     * Set application specific, custom metadata key-value pair
     * @deprecated Use addCustomMetadata instead
     *
     * @param {string} key
     * @param {any} value
     */
    metadata(key: string, value: any): void;
    /**
     * Set application specific, custom metadata key-value pair
     *
     * @param {string} key
     * @param {any} value
     */
    addCustomMetadata(key: string, value: any): void;
    /**
     * Remove application specific, custom metadata by key
     *
     * @param {string} key
     */
    removeCustomMetadata(key: string): void;
    /**
     * Return application specified custom metadata
     *
     * @returns {object}
     */
    customMetadata(): object;
    /**
     * Set log destination helper to an element
     *
     * TODO: remove this if it is unnecessary
     *
     * @param {string|object|any} destination
     */
    setLogDestination(destination: string | object | any): void;
    /**
     * Sets the transport method. `True` sets WS, `False` sets HTTP method.
     * @deprecated use setTransportMethod instead
     *
     * @param {boolean} useWsTransport
     */
    setUseWsTransport(useWsTransport: boolean): void;
    /**
     * Sets the transport method. Specify `ws` for Websocket transport,
     * `http` for HTTP transport. If you specify anything else the data is
     * not submitted to a server.
     * @param {string} transportMethod
     */
    setTransportMethod(transportMethod: string): void;
    /**
     * Enable / disable in-memory collection of events.
     *
     * @param {boolean} collectEvents
     */
    setCollectEvents(collectEvents: boolean): void;
    /**
     * Set the buffer size limit for in-memory event collection
     *
     * @param {number} sizeLimit
     */
    setEventCollectionSizeLimit(sizeLimit: number): void;
    /**
     * Set the metadata submission interval
     *
     * @param {number} metadataSubmissionInterval
     */
    setMetadataSubmissionInterval(metadataSubmissionInterval: number): void;
    /**
     * Enable/disable collecting URLs in the metadata
     *
     * @param {boolean} metadataCollectUrls
     */
    setMetadataCollectUrls(metadataCollectUrls: boolean): void;
    /**
     * Add metadata event to the stream (immediately, independently from the
     * periodic submission)
     *
     */
    submitMetadata(): void;
    /**
     * Enable / disable coalesced pointer event collection
     *
     * @param {boolean} capture
     */
    setCaptureCoalescedEvents(capture: boolean): void;
    /**
     * Enable / disable requestAnimationFrame message collection
     *
     * @param {boolean} capture
     */
    setCaptureRequestAnimationFrame(capture: boolean): void;
    /**
     * Log arbitrary messages
     *
     * @param {...any} props
     */
    log(...props: any[]): void;
    /**
     * Returns a deep copy of the collected events while keeping them unchanged in
     * Trap.
     *
     * @returns {undefined|Array<Array>}
     */
    collectedEvents(): undefined | Array<any[]>;
    /**
     * Returns the number of collected events. If `filterFn` is specified it
     * returns only the events that match the specified filter.
     *
     * @deprecated use collectedEvents instead and do the filtering and counting
     * in the calling application.
     *
     * @param {function(Array<any>):boolean} filterFn
     *
     * @returns {number}
     */
    collectedEventCount(filterFn?: (arg0: Array<any>) => boolean): number;
    /**
     * Generate a new streamId
     *
     * @param {boolean} resetStreamId
     */
    generateNewStreamId(): void;
    /**
     * Returns the collected events that have not been flushed yet.
     * Only works if `setCollectEvents(true)` was set before the data collection
     * was performed.
     *
     * @returns {undefined|Array<Array>}
     */
    flushCollectedEvents(): undefined | Array<any[]>;
    /**
     * Event handler when data is submitted by the transport layer.
     *
     * @param {(function(any[]):void) | undefined} callback
     */
    onDataSubmitted(callback: ((arg0: any[]) => void) | undefined): void;
    /**
     * `stopDataCollectionOnPageHide` setter
     *
     * @param {boolean} stop
     */
    stopDataCollectionOnPageHide(stop: boolean): void;
    /**
     * Event handler that is called when the visibility state of the page running
     * the Trap code changes.
     *
     * @private
     *
     * @param {'active'|'inactive'} pageState
     */
    private onPageStateChanged;
}

export { Trap, instance as default };