noibu-react-native 0.2.2 → 0.2.4

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/http-tools/HTTPDataBundler.d.ts

@@ -0,0 +1,112 @@
+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 extends Singleton {
+    contentTypeReadableRegex: RegExp;
+    hostname: string;
+    initialURLPartsReversed: string[];
+    httpDataCollectionEnabled: boolean;
+    httpDataAllowedRelativeRegex: RegExp | null;
+    httpDataAllowedAbsoluteRegex: RegExp | null;
+    /**
+     * Creates an instance of the ClickMonitor instance
+     */
+    constructor();
+    /**
+     * 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
+     */
+    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
+     * request or response headers
+     */
+    static headersMapFromIterable(headersIterable: Iterable<any[]>): Map<any, any>;
+    /**
+     * Takes a string of headers with 'name: value' and returns
+     * a map of strings representing headers.
+     * headersString is all the headers in one string
+     * returns a map of strings (as expected by metroplex) representing HTTP
+     * request or response headers
+     */
+    static headersMapFromString(headersString: unknown): Map<string, string>;
+    /**
+     * For an XHR object, checks the responseType property and handles the response or
+     * responseText property accordingly to return a string representation of the response.
+     * @returns a string representation of the response, or null if this fails.
+     */
+    static getResponseStringFromXHR(xhr: WrappedXMLHttpRequest): Promise<any>;
+    /**
+     * Builds an HTTP Data bundle
+     */
+    bundleHTTPData(url: string, requestHeaders: Map<string, string> | undefined, rawRequestPayload: any, responseHeaders: Map<string, string>, rawResponsePayload: any, method: string, isError: boolean): HTTPDataBundle | null;
+    /**
+     * Validates a request based on the URL and method. When enabled, will handle
+     * de-duping the requests
+     */
+    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.
+     * @param {string} url
+     * @returns boolean indicating whether the URL passed is either relative (in which case it is
+     * inherently on the current domain) or matches the current domain.
+     */
+    shouldContinueForURL(url: any): boolean;
+    /**
+     * Determines if the URL is absolute or relative
+     * returns boolean indicating whether the URL passed is either absolute or relative
+     */
+    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
+     */
+    shouldCollectPayloadForURL(url: any): boolean;
+    /**
+     * Double checks content length if we couldn't read the headers, and redacts PII
+     * returns the restricted payload
+     */
+    restrictPayload(payload: string, url: string, isError: boolean): string;
+    /**
+     * Returns true if the content-length header is of acceptable size.
+     * Too big gets rejected
+     * If the headers are not found, check actual content for length
+     * @param  {Headers} headers
+     * @returns boolean true if acceptable to collect
+     */
+    contentLengthAcceptable(headers: Map<string, string>, isError: boolean): boolean;
+    /**
+     * Returns true if the content type according to the headers is valid for collection.
+     * Also returns assumed true if content type is not stated in headers.
+     * @param {Map} headersMap
+     * @returns boolean true if acceptable to collect
+     */
+    private contentTypeAcceptable;
+    /**
+     * Returns a descriptive string if we have to drop payload based on the length
+     * or type listed in the headers passed. Returns an empty string otherwise.
+     */
+    getReasonPayloadIsDropped(headers: any, isError: boolean): string;
+    /**
+     * Returns content length from the headers, if available.
+     * If headers are not found or length is not a number, return -1
+     */
+    contentLength(headersObject: any): number;
+    /**
+     * Accepts a value that could be any type used as a request payload,
+     * and returns a string representation, or null if this fails.
+     */
+    stringFromRequestBody(value: any, requestHeaders?: Map<string, string>): any;
+    /**
+     * Removes possible PII from headers.
+     * @param {Map} dirtyHeaders a Map of HTTP response or request headers
+     * @returns {Map|null} a map of headers with PII redacted
+     */
+    removePIIHeaders(dirtyHeaders: Map<string, string> | undefined): typeof dirtyHeaders | null;
+}

package/dist/{monitors → 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

@@ -0,0 +1,24 @@
+import { Singleton } from '../../types/Monitor';
+/**
+ * Singleton class responsible for debouncing all events
+ * that are registered
+ */
+export declare class EventDebouncer extends Singleton {
+    private readonly eventsToDebounce;
+    /**
+     * Creates an instance of EventDebouncer
+     */
+    constructor();
+    /**
+     * 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: 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
+     */
+    _debouncePvEvents(type: string): void;
+    /** Sets up the page hide handler to try to push remaining events in the queues */
+    _setupUnloadHandler(): void;
+}

package/dist/{pageVisit → 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

@@ -0,0 +1,25 @@
+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: PVEventHTTPPayload;
+    httpData: HTTPDataBundle | null;
+    isGqlError: boolean;
+    /**
+     * Creates an instance of the http event for the pv
+     */
+    constructor(httpEvent: Partial<PVEventHTTPPayload>, httpData: HTTPDataBundle | null, isGqlError?: boolean);
+    /** Saves the HTTP event to the pageVisit Queue */
+    saveHTTPEvent(): void;
+    /**
+     * Checks if sending data is allowed based on the HTTP status code and count.
+     * status - The HTTP status code to evaluate.
+     * count - The count of events to consider.
+     * isGqlError - Whether the context is considered as a GQL error.
+     * Returns `true` if sending data is allowed, `false` otherwise.
+     */
+    static isSendAllowed(status: number, count: number, isGqlError?: boolean): boolean;
+}

package/dist/{sessionRecorder → src/sessionRecorder}/types.d.ts

@@ -84,7 +84,7 @@ export type RecorderEvent = {
 };
 export type NativeFrames = {
     p: (number | boolean | SubPicture)[][];
-    a: (number[] | (number | string[] | string | string[])[])[];
+    a: (number[] | (number | string | string[])[])[];
     e: (string | number)[];
 };
 export type UnsubscribeFn = () => void;

package/dist/{storage → 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/{storage → src/storage}/storage.d.ts

@@ -1,4 +1,4 @@
-import { IStorage, StorageValue } from '../types/Storage';
+import { IStorage, StorageValue } from '../../types/Storage';
 /**
  * Encapsulates storage api
  */
@@ -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/{storage → src/storage}/storageProvider.d.ts

@@ -1,4 +1,4 @@
-import { Provider, StorageValue } from '../types/Storage';
+import { Provider, StorageValue } from '../../types/Storage';
 /**
  * Base implementation for LocalStorage and SessionStorage
  */
@@ -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/{utils → src/utils}/function.d.ts

@@ -1,17 +1,21 @@
 import { RawStackFrame } from './stacktrace-parser';
 import { REQUIRED_DATA_PROCESSING_URLS } from '../constants';
-import { JError, JStackFrame } from '../types/PageVisit';
+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[]): JStackFrame[];
+export declare function processFrames(rawFrames: RawStackFrame[]): {
+    file: string;
+    line: string;
+    mname: string;
+    column?: number;
+}[];
 /**
  * Retrieves the javascript stack and message from an error event object
  * @param errObj error to extract stack from
@@ -19,11 +23,11 @@ export declare function processFrames(rawFrames: RawStackFrame[]): JStackFrame[]
 export declare function getJSStack(errObj: {
     stack: string;
     message: string;
-}): JError;
+}): JSErrorOutputMessage;
 /**
  * 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
  */
@@ -75,8 +79,24 @@ 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.
  */
 export declare function getVideoRecorderType(): Promise<string>;
+/** String.trim, but safe */
+export declare function safeTrim(text: unknown): string;
+/**
+ * Tries to get the stack trace from the given error object and returns it.
+ * If the error object does not have a stack trace, an empty string is returned.
+ *
+ * @param {Error} error - The error object from which to retrieve the stack trace.
+ * @returns {string} The stack trace of the error, if available. Otherwise, an empty string is returned.
+ */
+export declare function tryGetStackTrace(error: any): string;
+/**
+ * Checks whether the given value is a string or an instance of String.
+ * @param {*} value - The value to be checked.
+ * @returns {boolean} Returns true if the value is a string or an instance of String, otherwise returns false.
+ */
+export declare function isString(value: any): value is string | String;

package/dist/{utils → 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,23 +9,21 @@ 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
  * set to writeable.
- * @param {object} proto
- * @param {string} property
- * @returns {boolean} Whether the property on the prototype is (or is now) writeable
+ * returns Whether the property on the prototype is (or is now) writeable
  */
-export declare const propWriteableOrMadeWriteable: (proto: object, property: keyof typeof proto) => boolean;
+export declare const propWriteableOrMadeWriteable: <T>(proto: T, property: keyof T) => boolean;
 /**
  * Iterates object recursively and calls visit function
  * for each property allowing to override its value
@@ -38,4 +35,10 @@ export declare const propWriteableOrMadeWriteable: (proto: object, property: key
 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 {};
+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>;

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

@@ -0,0 +1,11 @@
+/**
+ * Redacts one string, returns redacted value or false if nothing to redact
+ */
+export declare function shouldRedact(field: string): boolean;
+/**
+ * Takes a string and redacts any PII we're able to detect
+ *
+ * content - the string from which we want to redact PII
+ * returns the string with any PII we're able to detect redacted.
+ */
+export declare function removePII(content: string): string;

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

@@ -0,0 +1,4 @@
+/**
+ * In case Promise.all is not available, use this polyfill
+ */
+export declare const promiseAll: any;

package/dist/storage/rnStorageProvider.js

@@ -1,3 +1,4 @@
+import { __awaiter } from 'tslib';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import StorageProvider from './storageProvider.js';
 
@@ -22,10 +23,12 @@ class RNStorageProvider extends StorageProvider {
      * Calculates used scape
      * @returns {Number}
      */
-    async calculateUsedSize() {
-        const keys = await AsyncStorage.getAllKeys();
-        const items = await AsyncStorage.multiGet(keys);
-        return items.reduce((sum, [key, item]) => sum + key.length + (item || '').length, 0);
+    calculateUsedSize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = yield AsyncStorage.getAllKeys();
+            const items = yield AsyncStorage.multiGet(keys);
+            return items.reduce((sum, [key, item]) => sum + key.length + (item || '').length, 0);
+        });
     }
 }
 

package/dist/storage/storage.js

@@ -1,14 +1,10 @@
+import { __awaiter } from 'tslib';
 import RNStorageProvider from './rnStorageProvider.js';
 
 /**
  * Encapsulates storage api
  */
 class Storage {
-    _isRNStorageAvailable;
-    _rnStorageError;
-    static _instance;
-    _provider;
-    _type;
     /**
      * Creates new instance assessing available options
      */
@@ -31,53 +27,65 @@ class Storage {
         return this._instance;
     }
     /** Checks if storage is available */
-    async isAvailable() {
-        return (await this._provider) !== null;
+    isAvailable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._provider) !== null;
+        });
     }
     /** Loads value from storage */
-    async load(key) {
-        const provider = await this._provider;
-        if (provider !== null) {
-            return provider.load(key);
-        }
-        return null;
+    load(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = yield this._provider;
+            if (provider !== null) {
+                return provider.load(key);
+            }
+            return null;
+        });
     }
     /** Saves value to storage */
-    async save(key, value) {
-        const provider = await this._provider;
-        if (provider !== null) {
-            return provider.save(key, value);
-        }
-        return undefined;
+    save(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = yield this._provider;
+            if (provider !== null) {
+                return provider.save(key, value);
+            }
+            return undefined;
+        });
     }
     /**
      * Removes value from storage
      * @param {String} key
      */
-    async remove(key) {
-        const provider = await this._provider;
-        if (provider !== null) {
-            return provider.remove(key);
-        }
-        return undefined;
+    remove(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = yield this._provider;
+            if (provider !== null) {
+                return provider.remove(key);
+            }
+            return undefined;
+        });
     }
     /** Calculates used scape */
-    async calculateUsedSize() {
-        const provider = await this._provider;
-        if (provider !== null) {
-            return provider.calculateUsedSize();
-        }
-        return 0;
+    calculateUsedSize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = yield this._provider;
+            if (provider !== null) {
+                return provider.calculateUsedSize();
+            }
+            return 0;
+        });
     }
     /**
      * Returns string indicating current provider type
      * and availability for other storage types
      * @returns {String}
      */
-    async getDiagnoseInfo() {
-        return `storage provider: ${await this
-            ._type} (rnStorage available: ${await this
-            ._isRNStorageAvailable}, error: ${await this._rnStorageError})`;
+    getDiagnoseInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return `storage provider: ${yield this
+                ._type} (rnStorage available: ${yield this
+                ._isRNStorageAvailable}, error: ${yield this._rnStorageError})`;
+        });
     }
 }
 

package/dist/storage/storageProvider.js

@@ -1,38 +1,42 @@
+import { __awaiter } from 'tslib';
 import { NOIBU_LOCAL_STORAGE_TEST_KEY } from '../constants.js';
 
 /**
  * Base implementation for LocalStorage and SessionStorage
  */
 class StorageProvider {
-    _provider;
     /** Creates new instance based on provided provider type */
     constructor(provider) {
         this._provider = provider;
     }
     /** Checks if provider is available */
-    static async isAvailable(resolver) {
-        let result = true;
-        let error = null;
-        try {
-            const provider = resolver();
-            await provider.setItem(NOIBU_LOCAL_STORAGE_TEST_KEY, '0');
-            await provider.removeItem(NOIBU_LOCAL_STORAGE_TEST_KEY);
-        }
-        catch (e) {
-            result = false;
-            error = e;
-        }
-        return { result, error };
+    static isAvailable(resolver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = true;
+            let error = null;
+            try {
+                const provider = resolver();
+                yield provider.setItem(NOIBU_LOCAL_STORAGE_TEST_KEY, '0');
+                yield provider.removeItem(NOIBU_LOCAL_STORAGE_TEST_KEY);
+            }
+            catch (e) {
+                result = false;
+                error = e;
+            }
+            return { result, error };
+        });
     }
     /**
      * Loads value from storage
      */
-    async load(key) {
-        const value = await this._provider.getItem(key);
-        if (value !== null) {
+    load(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield this._provider.getItem(key);
+            if (value !== null) {
+                return value;
+            }
             return value;
-        }
-        return value;
+        });
     }
     /** Saves value to storage */
     save(key, value) {