noibu-react-native 0.2.2 → 0.2.4

package/dist/{api → src/api}/clientConfig.d.ts

@@ -1,5 +1,5 @@
 import { SEVERITY } from '../constants';
-import { CustomerConfig, StoredConfig } from '../types/Config';
+import { CustomerConfig, StoredConfig } from '../../types/Config';
 /**
  * Singleton class to manage the client configuration
  * this class will be responsible for controlling the disabled
@@ -43,7 +43,7 @@ export default class ClientConfig {
     /**  Updates the config object to store the given last active time */
     updateLastActiveTime(lastActiveTime: Date): Promise<void>;
     /**  Gets the current page visit sequence number that should be used */
-    getPageVisitSeq(): Promise<number | null>;
+    getPageVisitSeq(): Promise<number>;
     /**
      *  Returns the client config object from storage or generates a new one
      * What is stored in storage will look like this

package/dist/{api → src/api}/helpCode.d.ts

@@ -1,23 +1,13 @@
+import { Singleton } from '../../types/Monitor';
 /**
  * HelpCode class is responsible for help code feature related functionality
  */
-export default class HelpCode {
+export default class HelpCode extends Singleton {
+    private requestContext;
     /**
-     * Singleton instance
-     * @returns {HelpCode}
+     * Constructs instance and sets up event listeners
      */
-    static getInstance(): HelpCode;
-    requestContext: {
-        resolve: null;
-        reject: null;
-        promise: null;
-    } | null;
-    /**
-     * Handles the received help code event.
-     * @param {CustomEvent<string>} event - The event object with string detail property.
-     * @returns {void}
-     */
-    receiveHelpCode(event: CustomEvent<string>): void;
+    constructor();
     /**
      * Requests a help code and returns a Promise that resolves when the help code is obtained
      * or rejects if the noibu connection is unavailable.
@@ -25,5 +15,9 @@ export default class HelpCode {
      * @returns {Promise<string>} Promise object representing the help code request.
      * @throws {string} Throws an error if the noibu connection is unavailable.
      */
-    requestHelpCode(): Promise<string>;
+    requestHelpCode(): Promise<unknown>;
+    /**
+     * Handles the received help code event.
+     */
+    receiveHelpCode(event: CustomEvent<string>): void;
 }

package/dist/{api → 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 { Singleton } from '../../types/Monitor';
+import { CompletePageVisit, InboundMessageType, OutboundMessageType, OutboundMessageTypeMap, PageVisitFrag, PageVisitInfo, SlidingMessage, VideoFrag } from '../../types/Metroplex.types';
+import { PVEventMessage } from '../../types/PageVisitEvents.types';
+/**
+ * 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: string;
-    ackedOnce: boolean;
+export default class MetroplexSocket extends Singleton {
+    forceClosed: boolean;
+    socket: WebSocket | null;
+    socketInstanceId: string | null;
+    previousMessageType: string;
+    currentConnectionAttempts: number;
     connectionCount: number;
-    connectionPromise: Promise<any>;
+    sessionStartTime: any;
+    connectionPromise: Promise<void> | null;
+    pageVisitInfoSent: boolean;
     connectionURL: string;
-    currentConnectionAttempts: number;
-    forceClosed: boolean;
-    helpCodeCb: null | ((...args: any[]) => any);
-    initialReferingURL: string;
-    static instance: MetroplexSocket;
-    instanceId: string | number[];
+    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;
-    latestReceivedSeqNumber: number;
-    messageSequenceNum: number;
-    metroRetryFrequencyMS: 30000;
-    metroplexTypeLock: Record<any, any>;
-    pageVisitInfoSent: boolean;
-    postURL: string;
-    previousMessageType: string;
-    retryMessageQueue: any[];
-    retryMetroplexInterval: null | number;
-    scriptInstanceId: string | number[] | undefined;
+    instanceId: string;
+    scriptInstanceId?: string;
     sessionLength: number;
-    sessionStartTime: any;
-    sessionTimestamp: Date;
-    socket: WebSocket | null;
-    socketInstanceId: string | number[] | null;
     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: string;
-        ref_url: string;
-        start_at: string;
-        conc: number;
-        cv: 2;
-        last: boolean;
-        script_id: string;
-        script_inst_id: string | number[] | undefined;
-        mp_sock_inst_id: string | number[];
-        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/{api → src/api}/storedPageVisit.d.ts

@@ -1,39 +1,30 @@
+import { Singleton } from '../../types/Monitor';
+import { CompletePageVisit, PageVisitFrag, PageVisitInfo, SlidingMessage } from '../../types/Metroplex.types';
 /**
  * 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/{constants.d.ts → 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";
@@ -243,3 +244,47 @@ export declare const BLOCKLISTED_DOMAINS: {
 export declare const MAX_RECORDER_EVENT_BUFFER = 10;
 export declare const MAX_TIME_FOR_RECORDER_USER_EVENTS = 2000;
 export declare const POST_METRICS_EVENT_NAME = "noibuPostMetrics";
+export declare const PAGE_CHECK_ERROR_ATT_NAME = "pagecheck_err";
+export declare const RESOURCE_ERROR_ATT_NAME = "res_err";
+export declare const GQL_EXTENSIONS_ATT_NAME = "extensions";
+export declare const GQL_LOCATIONS_ATT_NAME = "locations";
+export declare const GQL_SRC_ATT_NAME = "src";
+export declare const GQL_PATH_ATT_NAME = "path";
+export declare const GQL_LINE_ATT_NAME = "line";
+export declare const GQL_COLUMN_ATT_NAME = "column";
+export declare const GQL_MESSAGE_ATT_NAME = "message";
+export declare const GLOBAL_REASSIGN_ERROR_TYPE = "GlobalReassignError";
+export declare const PAGE_CHECK_ERROR_TYPE = "PageCheckError";
+export declare const IMAGE_ERROR_TYPE = "ImageError";
+export declare const JS_STACK_CAUSE_ATT_NAME = "cause";
+export declare const CUSTOM_ATTRIBUTE_TOTAL_COUNT_ATT_NAME = "cust_attr_total";
+export declare const CUSTOM_ATTRIBUTE_FAIL_COUNT_ATT_NAME = "cust_attr_fail";
+export declare const CUSTOM_ATTRIBUTE_KEY_COUNT_ATT_NAME = "cust_attr_key";
+export declare const OTHER_METRICS_ATT_NAME = "omm";
+export declare const OTHER_METRICS_KEYS: {
+    readonly STORAGE_FULL: "sf";
+    readonly STORAGE_UNAVAILABLE: "su";
+    readonly STORAGE_UNAVAILABLE_SECURITY_ERROR: "suse";
+};
+export declare const BODY_USED_ERROR = "Response data unavailable due to an improperly wrapped fetch call";
+export declare const MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT = 120;
+export declare const MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH = 65536;
+export declare const LOCATION_EVENT_TYPE = "loc";
+export declare const ECOMMERCE_EVENT_TYPE = "ecommerce";
+export declare const NETWORK_STATS_EVENT_TYPE = "network";
+export declare const TITLE_EVENT_TYPE = "title";
+export declare const PAGE_TYPE_EVENT_TYPE = "page_type";
+export declare const HTTP_DATA_COLLECTION_FLAG_NAME = "http_data_collection";
+export declare const HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME = "http_re";
+export declare const HELP_CODE_EVENT_NAME = "noibuHelpCode";
+export declare const ATTRIBUTE_SELECTORS_ATT_NAME = "att_sel";
+export declare const WIN_NJS_VERSION_ATT_NAME = "njs_version";
+export declare const WIN_SCRIPT_ID_ATT_NAME = "scriptID";
+export declare const WIN_BLOCKED_SELECTOR_ATT_NAME = "sel";
+export declare const DISABLED_STATUS_KEY = "DisabledStatus";
+export declare const CLIENT_UNLOCK_TIME_KEY = "ClientUnlockTime";
+export declare const BROWSER_ID_KEY = "BrowserId";
+export declare const CURRENT_PAGE_VISIT_COUNT_KEY = "CurrentPageVisitCount";
+export declare const PAGE_VISIT_ID_KEY = "pvId";
+export declare const LAST_ACTIVE_TIME_KEY = "LastActive";
+export declare const HELP_CODE_HASH_PARAM_NAME = "#helpcode";

package/dist/{entry → src/entry}/init.d.ts

@@ -1,4 +1,4 @@
-import { CustomerConfig } from '../types/Config';
+import { CustomerConfig } from '../../types/Config';
 /**
  * initilializes the script to start executing all of NJS features
  */

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

@@ -0,0 +1,18 @@
+import { Monitor, Singleton } from '../../types/Monitor';
+/**
+ * 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/ClickMonitor.d.ts

@@ -0,0 +1,31 @@
+/** @module ClickMonitor */
+import { Monitor, Singleton } from '../../types/Monitor';
+/** 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 '../../types/Monitor';
+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/{monitors/keyboardInputMonitor.d.ts → src/monitors/KeyboardInputMonitor.d.ts}

@@ -1,8 +1,10 @@
+import { Monitor, Singleton } from '../../types/Monitor';
 /**
  * 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/{monitors/pageMonitor.d.ts → src/monitors/PageMonitor.d.ts}

@@ -1,17 +1,14 @@
+import { Monitor, Singleton } from '../../types/Monitor';
+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 '../../types/Monitor';
+/**
+ * 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;
+}