noibu-react-native 0.2.3 → 0.2.5

package/dist/src/api/metroplexSocket.d.ts

@@ -1,67 +1,67 @@
-import { END_AT_ATT_NAME } from '../constants';
+import { PAGE_VISIT_PART_ATT_NAME, PAGE_VISIT_VID_FRAG_ATT_NAME } from '../constants';
+import { CompletePageVisit, InboundMessageType, OutboundMessageType, OutboundMessageTypeMap, PageVisitFrag, PageVisitInfo, SlidingMessage, VideoFrag } from '../../types/Metroplex.types';
+import { PVEventMessage } from '../../types/PageVisitEvents.types';
+import { Singleton } from '../monitors/BaseMonitor';
+/**
+ * Implements rolling window of specified size,
+ * but only makes a cut once array length exceeds 150%.
+ * During downsize deletes oldest (lowest indexes) elements.
+ */
+export declare function createSlidingArrayOfSize<T>(size: number, arraySource?: T[], downsizeThreshold?: number, downsizeFactor?: number): T[];
 /** Manages the socket to Metroplex */
-export default class MetroplexSocket {
-    _initialURL: any;
-    ackedOnce: any;
-    connectionCount: any;
-    connectionPromise: Promise<any>;
-    connectionURL: any;
-    currentConnectionAttempts: any;
-    forceClosed: any;
-    helpCodeCb: null | ((...args: any[]) => any);
-    initialReferingURL: any;
-    static instance: MetroplexSocket;
-    instanceId: any;
-    isRetryLoopDisabled: any;
-    latestReceivedSeqNumStoredTime: any;
-    latestReceivedSeqNumber: any;
-    messageSequenceNum: any;
-    metroRetryFrequencyMS: any;
-    metroplexTypeLock: Record<any, any>;
-    pageVisitInfoSent: any;
-    postURL: any;
-    previousMessageType: any;
-    retryMessageQueue: any[];
-    retryMetroplexInterval: null | number;
-    scriptInstanceId: any;
-    sessionLength: any;
-    sessionStartTime: any;
-    sessionTimestamp: any;
+export default class MetroplexSocket extends Singleton {
+    forceClosed: boolean;
     socket: WebSocket | null;
-    socketInstanceId: string | number[] | null;
+    socketInstanceId: string | null;
+    previousMessageType: string;
+    currentConnectionAttempts: number;
+    connectionCount: number;
+    sessionStartTime: any;
+    connectionPromise: Promise<void> | null;
+    pageVisitInfoSent: boolean;
+    connectionURL: string;
+    postURL: string;
+    messageSequenceNum: number;
+    latestReceivedSeqNumber: number;
+    isRetryLoopDisabled: boolean;
+    /** messages that need to be resent to metroplex since they are lacking confirmation */
+    retryMessageQueue: SlidingMessage<keyof OutboundMessageTypeMap>[];
+    metroplexTypeLock: Record<OutboundMessageType, boolean>;
+    initialURL: string;
+    initialReferringURL: string;
+    sessionTimestamp: Date;
+    latestReceivedSeqNumStoredTime: Date;
+    instanceId: string;
+    scriptInstanceId?: string;
+    sessionLength: number;
     socketCloseCodes: string[];
     socketOpens: string[];
+    ackedOnce: boolean;
+    metroRetryFrequencyMS: 30000;
+    retryMetroplexInterval: ReturnType<typeof setTimeout> | null;
+    private helpCodeCb;
     /**
      * Creates an instance of metroplex
      * id of script, to make sure only a single socket is open
      */
-    constructor(scriptInstanceId?: string | number[]);
-    /**
-     * gets the singleton instance
-     * @returns {MetroplexSocket}
-     */
-    static getInstance(scriptInstanceId?: string | number[]): MetroplexSocket;
+    constructor(scriptInstanceId?: string);
+    private static readonly typeToPayloadPropMap;
     /**
      * Adds the seq num field to the given payload depending on whether its
      * a page visit part or video frag
      */
-    _addSeqNumToPayload(type: string, payload: any): void;
-    /**
-     * sets the seq num in the payload for the given key and increments the
-     * global seq number
-     */
-    _setSeqNumInPayloadAndIncrementSeqNum(payloadKey: string, payload: any): void;
+    _addSeqNumToPayload<T>(type: OutboundMessageType, payload: T): T;
     /** requests help code and saves a callback to be called on response */
-    requestHelpCode(cb: (typeof this)['helpCodeCb']): Promise<boolean>;
+    requestHelpCode(cb: typeof this.helpCodeCb): Promise<boolean>;
     /**
      * Immediately sends a message to Metroplex over the web socket
      * Queues the message if the connection isn't open yet.
      * returns true if message was sent succefully, false otherwise
      */
-    sendMessage(type: string, payload: any): Promise<boolean>;
+    sendMessage<T extends OutboundMessageType>(type: T, payload: OutboundMessageTypeMap[T]): Promise<boolean>;
     /** Updates the latest pv message sent timestamp if events contain any user steps
      */
-    _updateLatestPvTimestamp(events: any[]): Promise<void>;
+    _updateLatestPvTimestamp(events: PVEventMessage[]): Promise<void>;
     /** returns true if the socket is either connecting or connected to metroplex */
     isConnected(): boolean;
     /** returns true if we are connecting to the socket */
@@ -75,25 +75,23 @@ export default class MetroplexSocket {
      * connectSocket will establish a websocket connection to the metroplex
      * service
      */
-    connectSocket(): Promise<any>;
+    connectSocket(): Promise<void>;
     /** Calculates and sets the end_at field of the payload
      * @param  {} payload
      * @param  {} isPageVisit
      */
-    addEndTimeToPayload(payload: any, isPageVisit: boolean): typeof payload & {
-        [END_AT_ATT_NAME]: string;
-    };
+    addEndTimeToPayload<T extends VideoFrag | PageVisitFrag>(payload: T, isPageVisit: boolean): T;
     /** open handler for socket */
     _onSocketOpen(): Promise<void>;
     /** message handler for socket
      * @param  {} event
      */
-    _onSocketMessage(event: any): Promise<void>;
+    _onSocketMessage(event: InboundMessageType): Promise<void>;
     /**
      * Returns true if the message's payload has the payload type given and has a sequence
      * number higher than seqNum
      */
-    _messagePayloadHasLargerSeqNum(message: any, payloadType: string, seqNum: number): any;
+    _messagePayloadHasLargerSeqNum(message: SlidingMessage, payloadType: typeof PAGE_VISIT_PART_ATT_NAME | typeof PAGE_VISIT_VID_FRAG_ATT_NAME, seqNum: number): boolean;
     /**
      * removes messages from the retry queue that are smaller than the
      * latest stored message in metroplex
@@ -118,39 +116,22 @@ export default class MetroplexSocket {
     /**
      * will send a message to metroplex via a post request that will outlive the current page
      */
-    postMessage(msg: any): Promise<void>;
+    postMessage(msg: CompletePageVisit): Promise<void>;
     /**
      * Stringifies the payload into JSON, sends it to the back end if the session
      * is active and returns true. If inactive the session and socket are closed
      * and this method returns false.
      */
-    _sendSocketMessage(payload: any): Promise<void>;
+    _sendSocketMessage<T extends ValueOf<OutboundMessageTypeMap>>(payload: T): Promise<void>;
     /**
      * Closes the socket connection if the session is inactive. Returns true if the
      * session is inactive
      */
     closeIfInactive(): Promise<boolean>;
     /** will get page information, calling this will increase the connection count */
-    getPageInformation(): Promise<{
-        br_id: string;
-        pv_id: string;
-        v: 5;
-        seq: number | null;
-        on_url: any;
-        ref_url: any;
-        start_at: any;
-        conc: any;
-        cv: 2;
-        last: boolean;
-        script_id: string;
-        script_inst_id: any;
-        mp_sock_inst_id: any;
-        sock_inst_id: string | number[] | null;
-        video_recorder: string;
-    }>;
+    getPageInformation(): Promise<PageVisitInfo>;
     /**
      * Try to parse help code response and fire custom event
-     * @param {String} response
      */
-    _tryProcessHelpCodeResponse(response: any): boolean;
+    _tryProcessHelpCodeResponse(response: unknown): boolean;
 }

package/dist/src/api/storedPageVisit.d.ts

@@ -1,39 +1,30 @@
+import { CompletePageVisit, PageVisitFrag, PageVisitInfo, SlidingMessage } from '../../types/Metroplex.types';
+import { Singleton } from '../monitors/BaseMonitor';
 /**
  * This class holds the final page visit. It flushes it to storage and then
  * finally sends it to Metroplex via the post route when the next page is loaded
  */
-export default class StoredPageVisit {
-    /** gets the singleton instance */
-    static getInstance(): StoredPageVisit;
-    latestPageVisitFrag: any;
-    writeTimeout: any;
-    flushedStorage: boolean;
+export default class StoredPageVisit extends Singleton {
+    /**
+     * Creates a new instance of StoredPageVisit
+     */
+    constructor();
     /**
      * Check if the events contain a click or location change. If they do then write the retry
      * queue (which contains the metroplex msg sent above) to storage
-     * @param  {} retryMessageQueue
-     * @param  {} pvInfo
      */
-    checkAndStoreRetryQueue(retryMessageQueue: any, pvInfo: any): void;
+    checkAndStoreRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
     /** Writes the page visit frags in the retry queue to storage
-     * @param  {} retryMessageQueue
-     * @param  {} pvInfo
      */
-    writePageVisitsFromRetryQueue(retryMessageQueue: any, pvInfo: any): void;
+    writePageVisitsFromRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
     /** Write the given page visit frags to storage
-     * @param  {} pageVisitFrags
-     * @param  {} pvInfo
      */
-    _writePageVisitFrags(pageVisitFrags: any, pvInfo: any): Promise<void>;
+    _writePageVisitFrags(pageVisitFrags: PageVisitFrag[], pvInfo: PageVisitInfo): Promise<void>;
     /**
      * Read the stored page visit from storage, create a complete page visit object
      * and then post that to Metroplex
      */
-    _getPostData(): Promise<{
-        pvi: any;
-        pvp: never[];
-        pvvf: never[];
-    } | null>;
+    _getPostData(): Promise<CompletePageVisit>;
     /**
      * Creates and tries to resolve a promise that posts the previous page visit
      * to Metroplex from storage
@@ -45,5 +36,5 @@ export default class StoredPageVisit {
      */
     _updateStorageFlushed(): void;
     /** Returns a promise that resolves to post the page visit in storage to Metroplex */
-    _getPostPageVisitPromise(): Promise<any>;
+    _getPostPageVisitPromise(): Promise<void>;
 }

package/dist/src/constants.d.ts

@@ -141,6 +141,7 @@ export declare const VIDEO_PART_COUNT_ATT_NAME: "vpnum";
 export declare const CSS_SEQ_SENT: "seq_sent";
 export declare const CSS_RECEIVED: "received";
 export declare const MAX_BEACON_PAYLOAD_SIZE: 59000;
+export declare const MAX_RETRY_MSG_Q_SIZE = 500;
 export declare const MAX_METROPLEX_CONNECTION_COUNT: 100;
 export declare const NOIBU_INPUT_URLS: string[];
 export declare const METROPLEX_FRAG_ROUTE: "pv_part";

package/dist/src/monitors/AppNavigationMonitor.d.ts

@@ -0,0 +1,18 @@
+import { Monitor, Singleton } from './BaseMonitor';
+/**
+ * Attaches corresponding listener to the passed navigation integration
+ */
+export declare class AppNavigationMonitor extends Singleton implements Monitor {
+    /**
+     * Main method for starting the monitoring
+     */
+    monitor(): void;
+    /**
+     * handler for updating navigation breadcrumbs and notifying metro of location change
+     */
+    private static onNavigation;
+    /**
+     * Called when the event needs to be emitted
+     */
+    private static reportLocationChange;
+}

package/dist/src/monitors/BaseMonitor.d.ts

@@ -0,0 +1,13 @@
+export interface Monitor {
+    monitor(): void;
+}
+/**
+ * Singleton pattern with our flavor
+ */
+export declare abstract class Singleton {
+    private static instances;
+    /** returns singleton instance */
+    static getInstance<T extends Singleton, A extends any[]>(this: new (...args: A) => T, ...args: A): T;
+    /** used for testing only */
+    protected resetInstances(): void;
+}

package/dist/src/monitors/BaseMonitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/monitors/ClickMonitor.d.ts

@@ -0,0 +1,31 @@
+/** @module ClickMonitor */
+import { Monitor, Singleton } from './BaseMonitor';
+/** Monitors the clicks which we capture and later process */
+export declare class ClickMonitor extends Singleton implements Monitor {
+    private static textCapturedWhiteListRegex;
+    private static htmlIDAllowListRegex;
+    private static originalCreateEventHandlers;
+    /** Starts monitoring clicks on every Press-able component */
+    monitor(): void;
+    /**
+     * Handles a single click event
+     */
+    private static onClickHandle;
+    /** Gets the textual content from an element, if any
+     */
+    private static getTextualContentFromEl;
+    /** Parse and trim text */
+    private static trimText;
+    /**
+     * Recursively parses element's inner content and masks blocked css classes
+     */
+    private static parseInnerContent;
+    /**
+     * Gets selectors to prevent those elements from being recorded
+     */
+    private static getBlockedElements;
+    /**
+     * normalize value and append to the resulting text if not empty
+     */
+    private static parseAndAppendText;
+}

package/dist/src/monitors/ErrorMonitor.d.ts

@@ -0,0 +1,63 @@
+import { Monitor, Singleton } from './BaseMonitor';
+type WrappedFunction<T extends Function = Function> = T & Partial<{
+    __noibu__: boolean;
+    __noibu_wrapped__: T;
+}>;
+/**
+ * wraps a provided function into a function that try and catches
+ * the original function, doing so allows us to catch errors
+ * functionToWrap: function to be wrapped
+ * @param  {} functionToWrap
+ */
+export declare function wrap(functionToWrap: WrappedFunction): Function;
+/**
+ * Monitors the errors happening on the window
+ */
+export declare class ErrorMonitor extends Singleton implements Monitor {
+    /** base method */
+    monitor(): void;
+    /** proxy error utils */
+    private static configureErrorUtilsHandler;
+    /**
+     * Handles a single error event
+     */
+    private static onErrorHandler;
+    /** proxy hermes engine */
+    private static configureHermesHooks;
+    /**
+     * handler for promise rejection failures
+     */
+    private static onPromiseRejectionHandler;
+    /**
+     * wraps and replaces the addEventListener property
+     * of event targets to try and catch errors
+     * eventTargetString: event target name
+     */
+    private static configureEventListeners;
+    /** iterates arguments to try to extract errors from them
+     */
+    private static processErrorLogArguments;
+    /**
+     * Constructs error objects based on console args.
+     * Relies on isStackTrace() to determine if arg is a stack trace, otherwise the arg must be a message.
+     *
+     * If there are multiple stack traces or the number of error messages is not equal to one,
+     * it maps the stack traces to objects with their respective first lines as messages.
+     * Otherwise, if there is exactly one stack trace and one error message,
+     * it constructs an array with a single object containing the first stack trace and the first error message.
+     * @param {Array<string>} args
+     */
+    private static constructErrors;
+    /**
+     * returns boolean that indicates wether we should
+     * ignore the next error event caught by the error event
+     * listener.
+     */
+    private static shouldIgnoreError;
+    /**
+     * transform a log into an error since React hides component errors
+     * https://reactjs.org/docs/error-boundaries.html
+     */
+    private static processErrorLog;
+}
+export {};

package/dist/src/monitors/{keyboardInputMonitor.d.ts → KeyboardInputMonitor.d.ts}

@@ -1,8 +1,10 @@
+import { Monitor, Singleton } from './BaseMonitor';
 /**
  * KeyboardInputMonitor is a listener class that attaches a
  * keyboard input listener of the document object.
  */
-export class KeyboardInputMonitor {
+export declare class KeyboardInputMonitor extends Singleton implements Monitor {
+    private static originalRender;
     /**
      * Begins the monitoring process
      * we currently only monitor two input locations: textarea and input
@@ -10,8 +12,9 @@ export class KeyboardInputMonitor {
     monitor(): void;
     /**
      * Validates an event
-     * @param uiViewClassName
-     * @param props
      */
-    _handle(uiViewClassName: any, props: any): void;
+    static handle(uiViewClassName: string, props: {
+        placeholder?: string;
+        testID?: string;
+    }): void;
 }

package/dist/src/monitors/{pageMonitor.d.ts → PageMonitor.d.ts}

@@ -1,17 +1,14 @@
+import { Monitor, Singleton } from './BaseMonitor';
+type Event = any;
 /** Monitors the page events which we capture and later process */
-export class PageMonitor {
-    /**
-     * gets the singleton instance
-     * @returns {PageMonitor}
-     */
-    static getInstance(): PageMonitor;
+export declare class PageMonitor extends Singleton implements Monitor {
     /** Starts monitoring page events on the document */
     monitor(): void;
     /**
      * Handles a single page event
-     * @param  {} event
+     * todo: don't think these events exist in RN world
      */
-    _onPageEventHandle(event: any): void;
+    _onPageEventHandle(event: Event): void;
     /** Returns document state */
     getDocumentState(): "hidden" | "active" | "passive";
     /**
@@ -20,3 +17,4 @@ export class PageMonitor {
      */
     getSizeInBytes(obj: any): number;
 }
+export {};

package/dist/src/monitors/RequestMonitor.d.ts

@@ -0,0 +1,94 @@
+/** @module RequestMonitor */
+import 'react-native/Libraries/Network/fetch';
+import { Monitor, Singleton } from './BaseMonitor';
+/**
+ * Monitors all requests
+ */
+export default class RequestMonitor extends Singleton implements Monitor {
+    /** main method */
+    monitor(): void;
+    /**
+     * Gets a response text Promise out of Response & headers. Returns reason if bundler decides to drop text.
+     * Due to async nature of text() and async function sent to Promise.all,
+     * our code race competes with client's code consuming the response.
+     * So at this point engine somehow gets access to the original ReadableStream and marks it as locked,
+     * thus client code may throw an error.
+     */
+    private static consumeResponseAndGetBodyText;
+    /**
+     * Generates new PVEventHTTP
+     */
+    private static getPvEventHttp;
+    /**
+     * Gets headers from request or request options. Handles different scenarios where simple conversion is not possible
+     */
+    private static getRequestHeaders;
+    /**
+     * Gets response headers.
+     * It is always a Headers object.
+     */
+    private static getResponseHeaders;
+    /**
+     * Gets request body from body strings or Request options
+     */
+    private static getRequestBody;
+    /**
+     * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
+     */
+    private static getHttpDataFromFetch;
+    /** Clones Response / Request or returns original object if cloning is not possible */
+    private static cloneResponse;
+    /**
+     * Handles fetch response safely. Reports PageVisitEventHTTP and error to Pagevisit if needed.
+     */
+    private static safeHandleFetchResponse;
+    /**
+     * Safe function to get method and url from fetch args
+     */
+    private static getMethodUrlFromFetchArgs;
+    /**
+     * Setting up the wrapper around fetch functions to try and
+     * catch http errors
+     */
+    private static setupGlobalFetchWrapper;
+    /**
+     * Does a check if data collection is enabled and combines it into HttpDataBundle
+     */
+    private static getHttpDataFromXhr;
+    /**
+     * on loadend we catch the event and
+     * make sure it was correct
+     */
+    private static loadendHandler;
+    /**
+     * Handles fetch failure
+     */
+    private static handleFetchFailure;
+    /** gets method from xhr */
+    private static getMethodFromXHR;
+    /**
+     * Wraps the send prototype of the xmlhttp object
+     * We set nbuWrapper to the handler function so if this returns an error
+     * the trace message will start with nbuWrapper which would allow us to
+     * detect that this is a wrapped function and not a NoibuJS error
+     */
+    private static wrapXMLHTTPSend;
+    /**
+     * Wraps the open prototype of the xmlhttp object
+     * We set nbuWrapper to the handler function so if this returns an error
+     * the trace message will start with nbuWrapper which would allow us to
+     * detect that this is a wrapped function and not a NoibuJS error
+     */
+    private static wrapXMLHTTPOpen;
+    /**
+     * Replaces the native XMLHTTPRequest.setHeader() function. We use this to build an array of
+     * request headers as these are not stored by the XMLHTTPRequest object.
+     * @param {object} proto window.XMLHTTPRequest's prototype
+     */
+    private static wrapXMLHTTPSetRequestHeader;
+    /**
+     * Setting up the wrapper around send functions to try and
+     * catch http errors
+     */
+    private static setupGlobalXMLHttpWrapper;
+}

package/dist/src/monitors/http-tools/GqlErrorValidator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Try detecting GraphQL errors from http response
+ */
+export default class GqlErrorValidator {
+    /**
+     * Retrieves GQL error object based on fetch request/response
+     */
+    static fromFetch(url: string, options: RequestInit | undefined, request: Request | undefined, response: Response): Promise<unknown[]>;
+    /**
+     * Retrieves GQL error object based on XHR object
+     */
+    static fromXhr(url: string, xhr: unknown): Promise<unknown[]>;
+    /**
+     * Try safely parse a string and return null if fails
+     */
+    static _parseJsonSafely(content: string): any;
+    /**
+     * Try to get content type for fetch arguments
+     */
+    static _getContentTypeFromFetchArguments(options?: RequestInit, request?: Request): string;
+    /**
+     * Checks if request is aborted
+     * If it has been aborted we are not able to consume the response
+     */
+    static _isRequestAborted(options?: RequestInit, request?: RequestInit): boolean;
+    /**
+     * Determines if request should be processed
+     */
+    static _shouldHandleRequest(url: string, contentType?: string | null): boolean;
+    /**
+     * Sanitizes payload object
+     */
+    static _validate(data: unknown, validationIssues: string[]): unknown[];
+    /**
+     * Sanitizes message object
+     */
+    static _validateMessage(error: object): void;
+    /**
+     * Sanitizes extensions object
+     * @param {any} error
+     */
+    static _validateExtensions(error: any): void;
+    /**
+     * Sanitizes locations object
+     */
+    static _validateLocations(error: object, validationIssues: string[]): void;
+    /**
+     * Sanitizes path object
+     */
+    static _validatePath(error: object, validationIssues: string[]): void;
+    /**
+     * Posts error
+     */
+    static _postError(message: unknown): void;
+    /**
+     * Posts issue found during object sanitization
+     */
+    static _postValidationIssues(validationIssues: string[]): void;
+}