noibu-react-native 0.2.1 → 0.2.3

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

@@ -0,0 +1,127 @@
+import { HTTPDataBundle } from '../../types/PageVisit.types';
+import { WrappedXMLHttpRequest } from '../../types/WrappedObjects';
+/** Bundles HTTP payloads and headers */
+export declare class HTTPDataBundler {
+    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;
+    /**
+     * 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: 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>;
+    /**
+     * 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
+     */
+    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
+     * @param {string} url
+     * @param {string} method
+     * @returns boolean indicating whether the validation passed
+     */
+    isValidRequest(url: any, method: any): 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;
+    /**
+     * Determins if the URL is absolute or relative
+     * @param {string} url
+     * @returns boolean indicating whether the URL passed is either absolute or relative
+     */
+    static isAbsoluteURL(url: any): 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/src/monitors/requestMonitor.d.ts

@@ -0,0 +1,10 @@
+/** @module RequestMonitor */
+import 'react-native/Libraries/Network/fetch';
+/**
+ * Handles fetch failure
+ */
+export declare function handleFetchFailure(maybeErr: unknown, url: unknown): void;
+/**
+ * Monitors all requests
+ */
+export declare function monitorRequests(): void;

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

@@ -0,0 +1,31 @@
+/**
+ * Singleton class responsible for debouncing all events
+ * that are registered
+ */
+export declare class EventDebouncer {
+    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;
+    /**
+     * 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/src/pageVisit/pageVisitEventHTTP.d.ts

@@ -0,0 +1,25 @@
+import { HTTPDataBundle, PVEventHTTP } from '../../types/PageVisit.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;
+    httpData: HTTPDataBundle | null;
+    isGqlError: boolean;
+    /**
+     * Creates an instance of the http event for the pv
+     */
+    constructor(httpEvent: Partial<PVEventHTTP>, 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: unknown;
+        error: Error | null;
     }>;
     /**
      * 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
  */

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
  */
@@ -7,9 +7,9 @@ export default abstract class StorageProvider {
     /** Creates new instance based on provided provider type */
     constructor(provider: Provider);
     /** Checks if provider is available */
-    static isAvailable(resolver: () => Provider): Promise<{
+    static isAvailable<T extends Provider>(resolver: () => T): Promise<{
         result: boolean;
-        error: unknown;
+        error: Error | null;
     }>;
     /**
      * Loads value from storage

package/dist/{utils → src/utils}/function.d.ts

@@ -1,6 +1,6 @@
 import { RawStackFrame } from './stacktrace-parser';
 import { REQUIRED_DATA_PROCESSING_URLS } from '../constants';
-import { JError, JStackFrame } from '../types/PageVisit';
+import { JSErrorOutputMessage } from '../../types/PageVisit.types';
 /**
  * returns a string that satisfies a max length
  * stringToVerify: string that needs to be verified
@@ -11,7 +11,12 @@ export declare function getMaxSubstringAllowed(stringToVerify: string, length?:
  * 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 +24,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: string): boolean;
 /**
  * counts the number of bytes
  */
@@ -80,3 +85,19 @@ export declare function isInstanceOf(instance: unknown, type: unknown): boolean;
  * 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

@@ -22,11 +22,9 @@ export declare function unwrapNoibuWrapped<T>(anything: {
  * 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 +36,11 @@ 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 declare const safeEntries: (obj: unknown | Record<string, string | null> | Headers) => [string, string | null][];
+/**
+ * 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/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,7 @@
+/**
+ * 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]>; }>;
+};

package/dist/storage/rnStorageProvider.js

@@ -1,7 +1,7 @@
+import { __awaiter } from 'tslib';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import StorageProvider from './storageProvider.js';
 
-// eslint-disable-next-line max-classes-per-file
 /**
  * React native storage provider implementation
  */
@@ -23,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) {

package/dist/types/Config.d.ts

@@ -1,27 +1,31 @@
-export interface Config {
-    sel: string[];
-    scriptID: string;
-    njs_version: string;
-    nid_cookie: boolean;
-    http_data_collection: boolean;
-    http_re: string[];
-}
-export interface CustomerConfig {
-    blockedElements?: Config['sel'];
-    listOfUrlsToCollectHttpDataFrom?: Config['http_re'];
-    enableHttpDataCollection?: Config['http_data_collection'];
-    domain: UrlConfig['domain'];
-}
+import { ATTRIBUTE_SELECTORS_ATT_NAME, BROWSER_ID_KEY, CLIENT_UNLOCK_TIME_KEY, CURRENT_PAGE_VISIT_COUNT_KEY, DISABLED_STATUS_KEY, HELP_CODE_EVENT_NAME, HTTP_DATA_COLLECTION_FLAG_NAME, HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME, LAST_ACTIVE_TIME_KEY, PAGE_VISIT_ID_KEY, POST_METRICS_EVENT_NAME, WIN_BLOCKED_SELECTOR_ATT_NAME, WIN_NJS_VERSION_ATT_NAME, WIN_SCRIPT_ID_ATT_NAME } from '../src/constants';
 export interface StoredConfig {
-    BrowserId: string;
-    LastActive?: Date;
-    pvId?: string;
-    CurrentPageVisitCount: number;
-    ClientUnlockTime?: Date;
-    DisabledStatus: boolean;
+    [BROWSER_ID_KEY]: string;
+    [LAST_ACTIVE_TIME_KEY]?: Date;
+    [PAGE_VISIT_ID_KEY]?: string;
+    [CURRENT_PAGE_VISIT_COUNT_KEY]: number;
+    [CLIENT_UNLOCK_TIME_KEY]?: Date;
+    [DISABLED_STATUS_KEY]: boolean;
 }
 export type UrlConfig = {
     metroplexSocketBase: string;
     metroplexHTTPBase: string;
     domain: string;
 };
+export interface CustomerConfig {
+    blockedElements?: NoibuConfig[typeof WIN_BLOCKED_SELECTOR_ATT_NAME];
+    listOfUrlsToCollectHttpDataFrom?: NoibuConfig[typeof HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME];
+    enableHttpDataCollection?: NoibuConfig[typeof HTTP_DATA_COLLECTION_FLAG_NAME];
+    domain: UrlConfig['domain'];
+}
+export interface NoibuConfig {
+    [WIN_BLOCKED_SELECTOR_ATT_NAME]: string;
+    [WIN_SCRIPT_ID_ATT_NAME]: string;
+    [WIN_NJS_VERSION_ATT_NAME]: string;
+    [ATTRIBUTE_SELECTORS_ATT_NAME]: string;
+    [POST_METRICS_EVENT_NAME]: string;
+    [HELP_CODE_EVENT_NAME]: string;
+    [HTTP_DATA_COLLECTION_FLAG_NAME]: string;
+    [HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME]: string[];
+    domain: string;
+}