noibu-react-native 0.2.3 → 0.2.4

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 '../../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/src/monitors/{keyboardInputMonitor.d.ts → 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/src/monitors/{pageMonitor.d.ts → 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;
+}

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;
+}

package/dist/src/monitors/{httpDataBundler.d.ts → http-tools/HTTPDataBundler.d.ts}

@@ -1,36 +1,32 @@
-import { HTTPDataBundle } from '../../types/PageVisit.types';
-import { WrappedXMLHttpRequest } from '../../types/WrappedObjects';
+import { WrappedXMLHttpRequest } from '../../../types/WrappedObjects';
+import { Singleton } from '../../../types/Monitor';
+import { HTTPDataBundle } from '../../../types/PageVisitEvents.types';
 /** Bundles HTTP payloads and headers */
-export declare class HTTPDataBundler {
+export declare class HTTPDataBundler extends Singleton {
     contentTypeReadableRegex: RegExp;
     hostname: string;
     initialURLPartsReversed: string[];
     httpDataCollectionEnabled: boolean;
     httpDataAllowedRelativeRegex: RegExp | null;
     httpDataAllowedAbsoluteRegex: RegExp | null;
-    private static instance;
     /**
      * Creates an instance of the ClickMonitor instance
      */
     constructor();
-    /** gets the singleton instance
-     * @returns {HTTPDataBundler}
-     * */
-    static getInstance(): HTTPDataBundler;
     /**
      * Builds the HTTP payload allowed regexes for full and relative URLs
      * @param allowedURLs A list of allowed URLs
      * @param absolute Use only absolute URLs if true, use only relative URL if false
      * @returns a regex of allowed URLs
      */
-    static buildAllowedRegex(allowedURLs: unknown | unknown[], absolute: boolean): RegExp | null;
+    private static buildAllowedRegex;
     /**
      * Takes an iterator and returns a map of strings representing headers.
-     * @param {object} headersIterable any iterable object
-     * @returns a map of strings (as expected by metroplex) representing HTTP
+     * param {object} headersIterable any iterable object
+     * returns a map of strings (as expected by metroplex) representing HTTP
      * request or response headers
      */
-    static headersMapFromIterable(headersIterable: any): Map<any, any>;
+    static headersMapFromIterable(headersIterable: Iterable<any[]>): Map<any, any>;
     /**
      * Takes a string of headers with 'name: value' and returns
      * a map of strings representing headers.
@@ -45,13 +41,6 @@ export declare class HTTPDataBundler {
      * @returns a string representation of the response, or null if this fails.
      */
     static getResponseStringFromXHR(xhr: WrappedXMLHttpRequest): Promise<any>;
-    /**
-     * Takes a URL and returns true if it is determined to be on the same domain as the URL
-     * the script is running on. Ignores protocol and path, and allows the URL to be a subdomain.
-     * @param {string} requestURL the URL of a request to compare to the script website's URL
-     * @param {bool} isHostnameCheck the URL is a domain hostname, could be a super or sub domain
-     */
-    isURLSameDomain(requestURL: any, isHostnameCheck?: boolean): boolean;
     /**
      * Builds an HTTP Data bundle
      */
@@ -59,11 +48,8 @@ export declare class HTTPDataBundler {
     /**
      * Validates a request based on the URL and method. When enabled, will handle
      * de-duping the requests
-     * @param {string} url
-     * @param {string} method
-     * @returns boolean indicating whether the validation passed
      */
-    isValidRequest(url: any, method: any): boolean;
+    isValidRequest(method: unknown): boolean;
     /**
      * Checks two things: that the URL is either on the same domain (or an address relative to the
      * current domain), and also checks that the config http_data_collection flag is enabled.
@@ -73,14 +59,13 @@ export declare class HTTPDataBundler {
      */
     shouldContinueForURL(url: any): boolean;
     /**
-     * Determins if the URL is absolute or relative
-     * @param {string} url
-     * @returns boolean indicating whether the URL passed is either absolute or relative
+     * Determines if the URL is absolute or relative
+     * returns boolean indicating whether the URL passed is either absolute or relative
      */
-    static isAbsoluteURL(url: any): boolean;
+    static isAbsoluteURL(url: unknown): boolean;
     /**
      * Checks whether HTTP payloads can be collected on this URL
-     * @returns boolean indicating whether HTTP payloads can be collected on this URL
+     * returns boolean indicating whether HTTP payloads can be collected on this URL
      */
     shouldCollectPayloadForURL(url: any): boolean;
     /**

package/dist/src/monitors/integrations/react-native-navigation-integration.d.ts

@@ -1,4 +1,5 @@
-import { NavigationIntegration } from '../../types/NavigationIntegration';
+import { NavigationIntegration } from '../../../types/NavigationIntegration';
+import { NavigationRoot } from 'react-native-navigation/lib/dist/src/Navigation';
 /**
  * react-native-navigation adapter
  */
@@ -8,7 +9,7 @@ export declare class ReactNativeNavigationIntegration implements NavigationInteg
     /**
      * attaches provided listeners to the integration
      */
-    register(navigation: any, onNavigation: (breadcrumbs: string[]) => void): void;
+    register(navigation: NavigationRoot, onNavigation: (breadcrumbs: string[]) => void): void;
     /**
      * Listens to ComponentWillAppear events, keeps track of visited screens and
      * pops them if the same page is visited to prevent cycles

package/dist/src/pageVisit/{eventDebouncer.d.ts → EventDebouncer.d.ts}

@@ -1,26 +1,19 @@
+import { Singleton } from '../../types/Monitor';
 /**
  * Singleton class responsible for debouncing all events
  * that are registered
  */
-export declare class EventDebouncer {
+export declare class EventDebouncer extends Singleton {
     private readonly eventsToDebounce;
-    private static instance;
     /**
      * Creates an instance of EventDebouncer
      */
     constructor();
-    /**
-     * gets the instance of EventDebouncer
-     */
-    static getInstance(): EventDebouncer;
-    /** will debounce all events that are of this type by the debounce period
-     */
-    registerInputType(type: string, debouncePeriod: number, eventName?: string): void;
     /**
      * Creates an event object with the event and the time it was added then pushes
      * that event object to the queue of events waiting to be debounced.
      */
-    addEvent(event: any, type: string, occurredAt?: number): void;
+    addEvent(event: any, type: keyof typeof this.eventsToDebounce, occurredAt?: number): void;
     /**
      * Adds the events from the object to the page visit and sets up a timer
      * to send the events if no more are received without the timeout

package/dist/src/pageVisit/pageVisit.d.ts

@@ -17,7 +17,7 @@ export class PageVisit {
      * @param  {} pvEvents
      * @param  {} partCounter
      */
-    static makePageVisitFrag(pvEvents: any, partCounter: any): any;
+    static makePageVisitFrag(pvEvents: any, partCounter: any): import("../../types/Metroplex.types").PageVisitFrag | import("../../types/Metroplex.types").VideoFrag;
     partCounter: number;
     pvMap: {};
     pvEventLength: number;

package/dist/src/pageVisit/pageVisitEventHTTP.d.ts

@@ -1,17 +1,17 @@
-import { HTTPDataBundle, PVEventHTTP } from '../../types/PageVisit.types';
+import { HTTPDataBundle, PVEventHTTPPayload } from '../../types/PageVisitEvents.types';
 /**
  * Determines if a response is a failure
  */
 export declare function isHttpCodeFailure(code: unknown): boolean;
 /** Class representing a PageVisitEventHTTP */
 export declare class PageVisitEventHTTP {
-    httpEvent: PVEventHTTP;
+    httpEvent: PVEventHTTPPayload;
     httpData: HTTPDataBundle | null;
     isGqlError: boolean;
     /**
      * Creates an instance of the http event for the pv
      */
-    constructor(httpEvent: Partial<PVEventHTTP>, httpData: HTTPDataBundle | null, isGqlError?: boolean);
+    constructor(httpEvent: Partial<PVEventHTTPPayload>, httpData: HTTPDataBundle | null, isGqlError?: boolean);
     /** Saves the HTTP event to the pageVisit Queue */
     saveHTTPEvent(): void;
     /**

package/dist/src/storage/rnStorageProvider.d.ts

@@ -13,7 +13,7 @@ export default class RNStorageProvider extends StorageProvider {
      */
     static isAvailable(): Promise<{
         result: boolean;
-        error: Error | null;
+        error: Error;
     }>;
     /**
      * Calculates used scape

package/dist/src/storage/storage.d.ts

@@ -20,7 +20,7 @@ export default class Storage implements IStorage {
     /** Checks if storage is available */
     isAvailable(): Promise<boolean>;
     /** Loads value from storage */
-    load<R = unknown>(key: string): Promise<R | null>;
+    load(key: string): Promise<string | null>;
     /** Saves value to storage */
     save(key: string, value: StorageValue): Promise<void>;
     /**

package/dist/src/storage/storageProvider.d.ts

@@ -9,12 +9,12 @@ export default abstract class StorageProvider {
     /** Checks if provider is available */
     static isAvailable<T extends Provider>(resolver: () => T): Promise<{
         result: boolean;
-        error: Error | null;
+        error: Error;
     }>;
     /**
      * Loads value from storage
      */
-    load<R = StorageValue>(key: string): Promise<R | null>;
+    load<R = StorageValue>(key: string): Promise<string | R>;
     /** Saves value to storage */
     save(key: string, value: StorageValue): Promise<void>;
     /**

package/dist/src/utils/function.d.ts

@@ -1,15 +1,14 @@
 import { RawStackFrame } from './stacktrace-parser';
 import { REQUIRED_DATA_PROCESSING_URLS } from '../constants';
-import { JSErrorOutputMessage } from '../../types/PageVisit.types';
+import { JSErrorOutputMessage } from '../../types/PageVisitErrors.types';
 /**
  * returns a string that satisfies a max length
  * stringToVerify: string that needs to be verified
  * length :optional, max length that stringToVerify can be
  */
-export declare function getMaxSubstringAllowed(stringToVerify: string, length?: 1024): string;
+export declare function getMaxSubstringAllowed(stringToVerify: string, length?: number): string;
 /**
  * Processes the raw stack frames and creates a readable stack in a safe manner
- * @param {StackFrame[]} rawFrames
  */
 export declare function processFrames(rawFrames: RawStackFrame[]): {
     file: string;
@@ -28,7 +27,7 @@ export declare function getJSStack(errObj: {
 /**
  * Checks if possiblyStacktrace has any stack frames present
  */
-export declare function isStackTrace(_possiblyStacktrace: string): boolean;
+export declare function isStackTrace(_possiblyStacktrace: unknown): _possiblyStacktrace is string;
 /**
  * counts the number of bytes
  */
@@ -80,7 +79,7 @@ export declare function maskTextInput(text: string): string;
  * It's safer than `instanceof` operator as it handles cases
  * where type is not actually a type but an object.
  */
-export declare function isInstanceOf(instance: unknown, type: unknown): boolean;
+export declare function isInstanceOf<T>(instance: unknown, type: T): instance is T;
 /**
  * To grab the video recorder type based on the device we run the app on.
  */

package/dist/src/utils/object.d.ts

@@ -1,5 +1,4 @@
 /** @module Object */
-type Func = (...args: any[]) => any;
 /**
  * Replaces an attribute value found in an object with another value
  * sourceObject: source object whose attribute will get replaced
@@ -10,14 +9,14 @@ type Func = (...args: any[]) => any;
  * @param  {} attributeName
  * @param  {} processingFunction
  */
-export declare const replace: <A extends { [k in K]: Func; }, K extends keyof A>(sourceObject: A, attributeName: K, processingFunction: (arg: A[K]) => A[K]) => void;
+export declare const replace: <A extends { [k in K]: Function; }, K extends keyof A>(sourceObject: A, attributeName: K, processingFunction: (arg: A[K]) => A[K]) => void;
 /**
  * unwraps wrapped property, so we can use it without side effects
  * @param anything
  */
 export declare function unwrapNoibuWrapped<T>(anything: {
     __noibu_original__?: T;
-} & T): NonNullable<T>;
+} & T): T;
 /**
  * Checks whether the prototype's property is writeable. If it is not,
  * checks whether the property can be made writeable. If it can, it is
@@ -36,11 +35,10 @@ export declare const propWriteableOrMadeWriteable: <T>(proto: T, property: keyof
 export declare const iterateObjectRecursively: (instance: Record<any, any>, visit: (i: typeof instance, p: keyof typeof i, v: (typeof i)[typeof p]) => typeof v, limit?: {
     depth: number;
 }) => void;
-export declare const safeEntries: (obj: unknown | Record<string, string | null> | Headers) => [string, string | null][];
+export declare const safeEntries: (obj: unknown | Record<string, string | null> | Headers) => [string, string][];
 /**
  * Replaces the behaviour of Object.fromEntries() as it is not supported on all browsers
  * @param {Iterable} entries The iterable to parse into an object
  * @returns An object containing the same key/values as the iterable passed
  */
 export declare const safeFromEntries: <T>(entries: unknown) => Record<string, T>;
-export {};

package/dist/src/utils/polyfills.d.ts

@@ -1,7 +1,4 @@
 /**
  * In case Promise.all is not available, use this polyfill
  */
-export declare const promiseAll: {
-    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
-    <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
-};
+export declare const promiseAll: any;