noibu-react-native 0.2.7 → 0.2.8

package/android/build.gradle

@@ -67,7 +67,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.noibu:sessionreplay-recorder:0.2.0"
+  implementation "com.noibu:sessionreplay-recorder:0.2.1"
 }
 
 if (isNewArchitectureEnabled()) {

package/dist/api/ClientConfig.d.ts

@@ -0,0 +1,99 @@
+import { ErrorMessage, Severity } from '@noibu/metroplex-ts-bindings';
+import { Singleton } from '../monitors/BaseMonitor';
+/**
+ * Singleton class to manage the client configuration
+ * this class will be responsible for controlling the disabled
+ * status of the client script as well as managing all storage
+ * storing and retrieval.
+ */
+export default class ClientConfig extends Singleton {
+    readonly pageVisitId: string;
+    browserId: StoredConfig['BrowserId'];
+    private pageVisitSeq;
+    private lastActiveTime;
+    private readonly noibuErrorURL;
+    private cltErrorPostCounter;
+    private readonly maxSocketInactiveTime;
+    private locationBreadcrumbs;
+    private readonly customerDomain;
+    isClientDisabled: boolean;
+    configurationPromise: Promise<void>;
+    readonly listOfUrlsToCollectHttpDataFrom: CustomerConfig['listOfUrlsToCollectHttpDataFrom'];
+    readonly enableHttpDataCollection: CustomerConfig['enableHttpDataCollection'];
+    readonly blockedElements: CustomerConfig['blockedElements'];
+    private alreadyPostingError;
+    /**  Error handling for constructor */
+    handleConstructorError(noibuErrorURL?: string, customerConfig?: CustomerConfig): void;
+    /** Creates a ClientConfig singleton instance */
+    constructor(noibuErrorURL?: string, customerConfig?: CustomerConfig);
+    /** Convenience method to check correct setup */
+    private hasAllNecessaryArgs;
+    /** lockClient will disable the client script for a single pagevisit for
+     * duration given in minuntes */
+    lockClient(duration: number, msg: ErrorMessage): Promise<void>;
+    /** Locks the client until the next page loads */
+    lockClientUntilNextPage(msg: ErrorMessage): Promise<void>;
+    /**  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>;
+    /**
+     *  Returns the client config object from storage or generates a new one
+     * What is stored in storage will look like this
+     *   {
+     * BrowserId: UUIDV4
+     * ExpiryTime: DATE OBJ
+     * DisabledStatus: BOOL
+     * CurrentPageVisitCount: INT
+     * ClientUnlockTime: DATE OBJ
+     * LastActiveTime: DATE OBJ
+     * }
+     */
+    _getLsObject(): Promise<StoredConfig>;
+    /** Check if we have surpassed the last active time and the page visit seq number needs resetting */
+    _pageVisitSeqNeedsReset(): Promise<boolean>;
+    /**
+     * _setupStorageVars will set all class variables that depend
+     * on the storage's value.
+     */
+    _setupStorageVars(): Promise<void>;
+    /**
+     *   Function will get the Noibu Storage Object
+     * 1. Generate a brand new one
+     * Get it from storage if the expiry date is not in the past
+     * Generate a brand new one if the expiry date is in the past
+     */
+    _getClientState(): Promise<StoredConfig>;
+    /**
+     * _generateAndStoreData generates brand new data and then proceeds to store
+     * it.
+     */
+    _generateAndStoreData(): Promise<StoredConfig>;
+    /**
+     * _generateNewBrowserData will create new data to be stored in storage
+     *   and persisted throughout a session
+     */
+    _generateNewBrowserData(): StoredConfig;
+    /**
+     * _storeBrowserData will store the passed object in storage.
+     * @param  {} data the data to be stored
+     */
+    _storeBrowserData(data: StoredConfig): Promise<StoredConfig>;
+    /** sets current breadcrumbs to be reconstructed into global url */
+    set currentLocationBreadcrumbs(newValue: typeof this.locationBreadcrumbs);
+    /** gets current global url */
+    get globalUrl(): string;
+    /**
+     * postInternalError will post errors that were thrown by collect
+     * and disable the client if required
+     * severity expects one of the SEVERITY_x level constants, or else error will be used
+     */
+    postInternalError(errorMsg: ErrorMessage, disableClient?: boolean, severity?: Severity, keepAlive?: boolean): Promise<void>;
+    /** Returns true if the page visit is considered to be inactive */
+    isInactive(): boolean;
+    /**
+     * Wraps a function in a try catch block and posts the error if one is thrown
+     * explanation will be inserted into the error message as 'Error in {explanation}'
+     */
+    wrapInternal(explanation: string, fun: () => void): void;
+}

package/dist/api/ClientConfig.js

@@ -1,11 +1,13 @@
 import { __awaiter } from 'tslib';
 import uuid from 'react-native-uuid';
-import { SEVERITY, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, GET_SCRIPT_ID, GET_DEVICE_ENV } from '../constants.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, GET_SCRIPT_ID, GET_DEVICE_ENV } from '../constants.js';
 import { stringifyJSON, getMaxSubstringAllowed, getUserAgent, postRequest } from '../utils/function.js';
 import Storage from '../storage/Storage.js';
-import { noibuLog, noibuErr } from '../utils/log.js';
+import { noibuLog } from '../utils/log.js';
 import { unwrapNoibuWrapped } from '../utils/object.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 // maximum number of page visits assigned to a single browser id
 const MAX_PAGEVISIT_VISITED = 300;
@@ -32,7 +34,7 @@ class ClientConfig extends Singleton {
             customerConfig,
             globalUrl: this.globalUrl,
         };
-        void this.postInternalError(reason, true, SEVERITY.error);
+        void this.postInternalError(reason, true, Severity.ERROR);
         this.configurationPromise = Promise.reject(reason);
     }
     /** Creates a ClientConfig singleton instance */
@@ -52,6 +54,7 @@ class ClientConfig extends Singleton {
         this.maxSocketInactiveTime = MAX_METROPLEX_SOCKET_INNACTIVE_TIME;
         this.locationBreadcrumbs = [];
         this.isClientDisabled = false;
+        this.alreadyPostingError = false;
         if (!noibuErrorURL || !customerConfig) {
             this.handleConstructorError(noibuErrorURL, customerConfig);
             return;
@@ -82,12 +85,12 @@ class ClientConfig extends Singleton {
             noibuLSObject.DisabledStatus = true;
             noibuLSObject.ClientUnlockTime = expiryTime;
             yield this._storeBrowserData(noibuLSObject);
-            yield this.postInternalError(msg, true, SEVERITY.warn);
+            yield this.postInternalError(msg, true, Severity.WARN);
         });
     }
     /** Locks the client until the next page loads */
     lockClientUntilNextPage(msg) {
-        return this.postInternalError(msg, true, SEVERITY.warn);
+        return this.postInternalError(msg, true, Severity.WARN);
     }
     /**  Updates the config object to store the given last active time */
     updateLastActiveTime(lastActiveTime) {
@@ -171,7 +174,7 @@ class ClientConfig extends Singleton {
         return __awaiter(this, void 0, void 0, function* () {
             const storage = Storage.getInstance();
             if (!(yield storage.isAvailable())) {
-                void this.postInternalError({ msg: `Storage is unavailable, disabling client.`, diagnosis: yield storage.getDiagnoseInfo() }, true, SEVERITY.error);
+                void this.postInternalError({ msg: `Storage is unavailable, disabling client.`, diagnosis: yield storage.getDiagnoseInfo() }, true, Severity.ERROR);
                 return;
             }
             // getting the current content of the storage
@@ -201,7 +204,7 @@ class ClientConfig extends Singleton {
                 // setting the lock time
                 noibuLSObject.ClientUnlockTime = expiryTime;
                 noibuLSObject.DisabledStatus = true;
-                yield this.postInternalError({ msg: `Hit max page visits, disabling client for ${CLIENT_LOCK_TIME_MINUTES}mins` }, true, SEVERITY.error);
+                yield this.postInternalError({ msg: `Hit max page visits, disabling client for ${CLIENT_LOCK_TIME_MINUTES}mins` }, true, Severity.ERROR);
             }
             // we now check if we successfully saved the data
             const savedData = yield this._storeBrowserData(noibuLSObject);
@@ -209,7 +212,7 @@ class ClientConfig extends Singleton {
             // error happened, thus we disable collect.
             if (!savedData.BrowserId) {
                 // we do not set a lock expiry date here since we cannot store to storage
-                void this.postInternalError({ msg: `Null browser in storage, disabling client` }, true, SEVERITY.error);
+                void this.postInternalError({ msg: `Null browser in storage, disabling client` }, true, Severity.ERROR);
                 this.browserId = '';
             }
         });
@@ -269,7 +272,7 @@ class ClientConfig extends Singleton {
                 yield this.postInternalError({
                     msg: 'Error writing browser data to storage, disabling client: ' + e.message,
                     diagnosis: yield storage.getDiagnoseInfo(),
-                }, true, SEVERITY.error);
+                }, true, Severity.ERROR);
                 // sending empty fields if we encountered errors while storing in the LS
                 return this._generateNewBrowserData();
             }
@@ -297,23 +300,21 @@ class ClientConfig extends Singleton {
      * severity expects one of the SEVERITY_x level constants, or else error will be used
      */
     postInternalError(errorMsg_1) {
-        return __awaiter(this, arguments, void 0, function* (errorMsg, disableClient = false, severity = SEVERITY.error, keepAlive = false) {
-            noibuErr('postInternalError', {
-                errorMsg,
-                disableClient,
-                severity,
-                keepAlive,
-            });
-            if (this.isClientDisabled) {
+        return __awaiter(this, arguments, void 0, function* (errorMsg, disableClient = false, severity = Severity.ERROR, keepAlive = false) {
+            if (this.alreadyPostingError || this.isClientDisabled || severity === Severity.WARN) {
                 return;
             }
             if (disableClient) {
                 this.isClientDisabled = true;
             }
-            if (severity === SEVERITY.warn) {
-                // don't log warning messages by default, as a cost savings
-                return;
-            }
+            this.alreadyPostingError = true;
+            /** Don't use noibuErr here since we end up in recursion due to RN log intercept in debug mode */
+            noibuLog('postInternalError', {
+                errorMsg,
+                disableClient,
+                severity,
+                keepAlive,
+            });
             const collectError = {
                 browserId: this.browserId || '',
                 pageVisitId: this.pageVisitId,
@@ -361,9 +362,10 @@ class ClientConfig extends Singleton {
                 });
             }
             // only increment if this was an actual error, not a warning or otherwise
-            if (severity === SEVERITY.error) {
+            if (severity === Severity.ERROR) {
                 this.cltErrorPostCounter += 1;
             }
+            this.alreadyPostingError = false;
         });
     }
     /** Returns true if the page visit is considered to be inactive */
@@ -381,7 +383,7 @@ class ClientConfig extends Singleton {
             fun();
         }
         catch (error) {
-            this.postInternalError({ msg: `Error in ${explanation}`, error }, false, SEVERITY.error);
+            this.postInternalError({ msg: `Error in ${explanation}`, error }, false, Severity.ERROR);
         }
     }
 }

package/dist/api/ClientConfig.test.d.ts

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

package/dist/api/HelpCode.d.ts

@@ -0,0 +1,16 @@
+import { Singleton } from '../monitors/BaseMonitor';
+/**
+ * HelpCode class is responsible for help code feature related functionality
+ */
+export default class HelpCode extends Singleton {
+    private requestContext;
+    /** Constructs instance and sets up event listeners */
+    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.
+     */
+    requestHelpCode(): Promise<string | null>;
+    /** Handles the received help code event. */
+    receiveHelpCode(event: CustomEvent<string>): void;
+}

package/dist/api/HelpCode.js

@@ -1,8 +1,9 @@
 import { __awaiter } from 'tslib';
 import MetroplexSocket from './MetroplexSocket.js';
-import { SEVERITY } from '../constants.js';
 import ClientConfig from './ClientConfig.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 /**
  * HelpCode class is responsible for help code feature related functionality
@@ -48,7 +49,7 @@ class HelpCode extends Singleton {
             const { success, data } = event.detail;
             if (!success) {
                 const msg = `Noibu help code is not available due to ${data}`;
-                ClientConfig.getInstance().postInternalError({ msg }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg }, false, Severity.ERROR);
             }
             return;
         }

package/dist/api/InputManager.d.ts

@@ -0,0 +1,39 @@
+import { Singleton } from '../monitors/BaseMonitor';
+declare const NOIBUJS_SDK_REQUEST_HELP_CODE = "requestHelpCode";
+declare const NOIBUJS_SDK_ADD_ID_FUNCTION = "addCustomAttribute";
+declare const NOIBUJS_SDK_ADD_ERROR_FUNCTION = "addError";
+declare const NOIBUJS_SDK_ADD_ERROR_FROM_JS_FMW_FUNCTION = "addJsSdkError";
+/** this class controls the input that customers can inject into
+ * our script via the NoibuJS SDK
+ */
+export default class InputManager extends Singleton {
+    private readonly customIDs;
+    private customErrorsCount;
+    /** exposes functions to the window of the browser for the clients
+     * to interact with on their end
+     */
+    exposeFunctions(): {
+        [NOIBUJS_SDK_REQUEST_HELP_CODE]: () => Promise<string | null>;
+        [NOIBUJS_SDK_ADD_ID_FUNCTION]: (name: string, value: string) => Promise<string>;
+        [NOIBUJS_SDK_ADD_ERROR_FUNCTION]: (customError: unknown) => string;
+        [NOIBUJS_SDK_ADD_ERROR_FROM_JS_FMW_FUNCTION]: (customError: unknown, errorSource: unknown) => string;
+    };
+    /** validates the custom error that was passed */
+    getErrorValidationError(customError: any): "SUCCESS" | "ERROR_HAS_NO_MSG" | "ERROR_HAS_NO_STACK" | "NULL_CUSTOM_ERROR";
+    /** Validates and sets the custom error to our internal trackers */
+    _validateAndSetCustomError(customError: unknown): "SUCCESS" | "ERROR_HAS_NO_MSG" | "ERROR_HAS_NO_STACK" | "NULL_CUSTOM_ERROR" | "TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT";
+    /** adds an error from a JS Sdk to the session */
+    _addErrorFromJSSdk(customError: unknown, errorSource: unknown): "SUCCESS" | "ERROR_HAS_NO_MSG" | "ERROR_HAS_NO_STACK" | "NULL_CUSTOM_ERROR" | "TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT";
+    /** adds a custom Error to the session */
+    _addCustomError(customError: unknown): "SUCCESS" | "ERROR_HAS_NO_MSG" | "ERROR_HAS_NO_STACK" | "NULL_CUSTOM_ERROR" | "TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT";
+    /**
+     * adds a custom id to the session
+     * todo wrong param types, should be unknown
+     */
+    _addCustomAttribute(name: string, value: string): Promise<"TOO_MANY_IDS_ADDED" | "ID_NAME_ALREADY_ADDED" | "NAME_TOO_LONG" | "VALUE_TOO_LONG" | "INVALID_NAME_TYPE" | "INVALID_VALUE_TYPE" | "NAME_HAS_NO_LENGTH" | "VALUE_HAS_NO_LENGTH" | "SUCCESS">;
+    /** validation function for customer input */
+    getValidationError(name: unknown, value: unknown): "NAME_TOO_LONG" | "VALUE_TOO_LONG" | "INVALID_NAME_TYPE" | "INVALID_VALUE_TYPE" | "NAME_HAS_NO_LENGTH" | "VALUE_HAS_NO_LENGTH" | "SUCCESS";
+    /** Requests a help code from the HelpCode instance. */
+    _requestHelpCode(): Promise<string | null>;
+}
+export {};

package/dist/api/MetroplexSocket.d.ts

@@ -0,0 +1,132 @@
+import { MetroplexInputRouteMap, MetroplexRoute, PageInformation, PageVisitEvent, VideoRecorder, WebsocketMessageType } from '@noibu/metroplex-ts-bindings';
+import { Singleton } from '../monitors/BaseMonitor';
+import { NoSeqNumSlidingMessage, RetryQueueWSMessage } from '../types/Metroplex';
+/**
+ * Grab the video recorder type based on the device we run the app on.
+ */
+export declare function getVideoRecorderType(): Promise<VideoRecorder>;
+/**
+ * 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 extends Singleton {
+    forceClosed: boolean;
+    socket: WebSocket | null;
+    socketInstanceId: string | null;
+    previousMessageType: string;
+    currentConnectionAttempts: number;
+    connectionCount: number;
+    sessionStartTime: number;
+    connectionPromise: Promise<void>;
+    pageVisitInfoSent: boolean;
+    connectionURL: string;
+    postURL: string;
+    messageSequenceNum: number;
+    latestReceivedSeqNumber: number;
+    isRetryLoopDisabled: boolean;
+    /** messages that need to be resent to metroplex since they are lacking confirmation */
+    retryMessageQueue: RetryQueueWSMessage[];
+    metroplexTypeLock: Record<WebsocketMessageType, boolean>;
+    initialURL: string;
+    initialReferringURL: string;
+    sessionTimestamp: Date;
+    latestReceivedSeqNumStoredTime: Date;
+    instanceId: string;
+    scriptInstanceId?: string;
+    sessionLength: number;
+    socketCloseCodes: string[];
+    socketOpens: string[];
+    ackedOnce: boolean;
+    metroRetryFrequencyMS: number;
+    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);
+    /**
+     * connectSocket will establish a websocket connection to the metroplex
+     * service
+     */
+    connectSocket(): Promise<void>;
+    /** sets up events that will trigger the event queue to be emptied */
+    _setupOffloadEvents(): void;
+    /**
+     * Adds the seq num field to the given payload depending on whether its
+     * a page visit part or video frag
+     */
+    _addSeqNumToPayload<T extends RetryQueueWSMessage>(message: NoSeqNumSlidingMessage<T>): Promise<T>;
+    /** requests help code and saves a callback to be called on response */
+    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(message: NoSeqNumSlidingMessage<RetryQueueWSMessage<WebsocketMessageType>>): Promise<boolean>;
+    /** Updates the latest pv message sent timestamp if events contain any user steps
+     */
+    _updateLatestPvTimestamp(events: PageVisitEvent[]): 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 */
+    isConnecting(): boolean;
+    /** close will close the socket opened for video frag transmission */
+    close(): void;
+    /** Connects the web socket to metroplex and calls callback upon successfully connecting
+     */
+    handleConnect(forceOpen: boolean): Promise<void>;
+    /** Calculates and sets the end_at field of the payload   */
+    addEndTimeToPayload<T>(payload: T, isPageVisit: boolean): T & {
+        end_at: string;
+    };
+    /** open handler for socket */
+    _onSocketOpen(): Promise<void>;
+    /** message handler for socket  */
+    _onSocketMessage(event: WebSocketMessageEvent): Promise<void>;
+    /**
+     * Returns true if the message's payload has the payload type given and has a sequence
+     * number higher than seqNum
+     */
+    _messagePayloadHasLargerSeqNum(message: RetryQueueWSMessage, seqNum: number): boolean | 0;
+    /**
+     * removes messages from the retry queue that are smaller than the
+     * latest stored message in metroplex
+     */
+    _clearRetryQueue(seqNum: number): void;
+    /** will resend everything that is in the retry queue */
+    _sendUnconfirmedMessages(socketWasAlreadyOpen: boolean): Promise<void>;
+    /** sets up the interval to empty the queue as we receive confirmation messages from metroplex */
+    setupRetryMechanism(): void;
+    /**
+     * will handle the final moments of a page being active. It
+     * will try to empty both the queues with beacons.
+     */
+    _handleUnload(): Promise<void>;
+    /**
+     * will post full page visit to metroplex. It
+     * will try to empty both the queues with beacons.
+     */
+    postFullPageVisit(maxMessageSize: number): Promise<void>;
+    /** will send a message to metroplex via a post request that will outlive the current page */
+    postMessage(msg: MetroplexInputRouteMap[MetroplexRoute.PageVisit]): 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.
+     */
+    private sendSocketMessage;
+    /**
+     * 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<PageInformation>;
+    /** Try to parse help code response and fire custom event */
+    _tryProcessHelpCodeResponse(response: unknown): boolean;
+}

package/dist/api/MetroplexSocket.js

@@ -4,7 +4,7 @@ import { Platform } from 'react-native';
 import { MetroplexRoute } from '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
 import { getUserAgent, stringifyJSON } from '../utils/function.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
-import { GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_POST_URL, GET_MAX_METROPLEX_RECONNECTION_NUMBER, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, SEVERITY, MAX_BEACON_PAYLOAD_SIZE, CURRENT_NOIBUJS_VERSION, GET_SCRIPT_ID } from '../constants.js';
+import { GET_METROPLEX_BASE_SOCKET_URL, GET_METROPLEX_POST_URL, GET_MAX_METROPLEX_RECONNECTION_NUMBER, GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY, MAX_BEACON_PAYLOAD_SIZE, CURRENT_NOIBUJS_VERSION, GET_SCRIPT_ID } from '../constants.js';
 import ClientConfig from './ClientConfig.js';
 import StoredMetrics from './StoredMetrics.js';
 import StoredPageVisit from './StoredPageVisit.js';
@@ -16,6 +16,7 @@ import { Singleton } from '../monitors/BaseMonitor.js';
 import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
 import { WorkRequestMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WorkRequestMessageType.js';
 import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 import { InboundMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/InboundMessageType.js';
 
 /**
@@ -387,7 +388,7 @@ class MetroplexSocket extends Singleton {
                     if (event.data.includes('seq_num')) {
                         const seqNumSplit = event.data.split('seq_num:');
                         if (seqNumSplit.length < 2) {
-                            ClientConfig.getInstance().postInternalError({ msg: `Invalid message received from metroplex while clearing retry queue`, data: event.data }, false, SEVERITY.error);
+                            ClientConfig.getInstance().postInternalError({ msg: `Invalid message received from metroplex while clearing retry queue`, data: event.data }, false, Severity.ERROR);
                             break;
                         }
                         // the second element in the string split is the sequence number
@@ -607,7 +608,7 @@ class MetroplexSocket extends Singleton {
                 // debug message gets through
                 const clientDisabled = ClientConfig.getInstance().isClientDisabled;
                 ClientConfig.getInstance().isClientDisabled = false;
-                ClientConfig.getInstance().postInternalError(message, clientDisabled, SEVERITY.warn);
+                ClientConfig.getInstance().postInternalError(message, clientDisabled, Severity.WARN);
             }
         });
     }

package/dist/api/MetroplexSocket.test.d.ts

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

package/dist/api/StoredMetrics.d.ts

@@ -0,0 +1,63 @@
+import { Singleton } from '../monitors/BaseMonitor';
+/**
+ * This class holds the final page visit and video frag metrics. It flushes
+ * them to storage and then finally sends them to Metroplex via the post
+ * route when the next page is loaded
+ */
+export default class StoredMetrics extends Singleton {
+    expectedVideoLength: number;
+    expectedVfSeq: number;
+    httpSequenceNumber: number;
+    httpOverLimitCount: number;
+    httpDroppedPayloadByTypeCount: number;
+    httpDroppedPayloadByLengthCount: number;
+    httpPayloadCount: number;
+    expectedPvPart: number;
+    videoClicks: number;
+    pvClicks: number;
+    errCount: number;
+    httpCount: number;
+    didCutPv: boolean;
+    didCutVideo: boolean;
+    didStartVideo: boolean;
+    /** Creates a new StoredMetrics instance */
+    constructor();
+    /** Add video frag payload data to the stored metrics   */
+    addVideoFragData(expectedVfSeq: number, expectedVideoLength: number): void;
+    /** Set the amount of page visit parts   */
+    setPvPart(expectedPvPart: number): void;
+    /** Increase the amount of video clicks seen in the session */
+    addVideoClick(): void;
+    /** Increase the amount of page visit clicks */
+    addPvClick(): void;
+    /** Increments the error count by 1 */
+    addError(): void;
+    /** Increments the http count by 1 */
+    addHttpEvent(): void;
+    /** Increments the http data sequence count by 1 */
+    addHttpData(): void;
+    /** Increments the http data over limit count by 1 */
+    addHttpDataOverLimit(): void;
+    /** Increments the http data drop count by content type */
+    addHttpDataDropByType(): void;
+    /** Increments the http data drop count by content length */
+    addHttpDataDropByLength(): void;
+    /** Increments the http data payload collected count */
+    addHttpDataPayloadCount(): void;
+    /** Set that the video was cut/blocked due to size constraints */
+    setDidCutVideo(): void;
+    /** Set that the video was started */
+    setDidStartVideo(): void;
+    /** Set that the page visit was cut/blocked due to size constraints */
+    setDidCutPv(): void;
+    /**
+     * Sets up all the listeners that noibujs should listen to before storing
+     * our metrics to localstorage
+     */
+    _setupListeners(): void;
+    /** posts the metrics to metroplex if client is active   */
+    private postMetricsIfActive;
+    /** posts the metrics to metroplex using the beacon API
+     */
+    postMetrics(): Promise<void>;
+}

package/dist/api/StoredPageVisit.d.ts

@@ -0,0 +1,43 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { RetryQueueWSMessage } from '../types/Metroplex';
+import { CompletePageVisitPart, PageInformation, PageVisitPart } from '@noibu/metroplex-ts-bindings';
+/**
+ * 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 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
+     */
+    checkAndStoreRetryQueue(retryMessageQueue: RetryQueueWSMessage[], pvInfo: PageInformation): void;
+    /** Writes the page visit frags in the retry queue to storage
+     */
+    writePageVisitsFromRetryQueue(retryMessageQueue: RetryQueueWSMessage[], pvInfo: PageInformation): void;
+    /** Write the given page visit frags to storage
+     */
+    _writePageVisitFrags(pageVisitFrags: PageVisitPart[], pvInfo: PageInformation): Promise<void>;
+    /**
+     * Handles any issues that may appear when trying to get the stored page visit data
+     */
+    static handleGetPostDataError(data: string, error: Error): Promise<null>;
+    /**
+     * Read the stored page visit from storage, create a complete page visit object
+     * and then post that to Metroplex
+     */
+    _getPostData(): Promise<CompletePageVisitPart | null>;
+    /**
+     * Creates and tries to resolve a promise that posts the previous page visit
+     * to Metroplex from storage
+     */
+    _postPreviousPageVisit(): void;
+    /**
+     * Remove the storage item and set flushed to true after they have
+     * been posted to metroplex
+     */
+    _updateStorageFlushed(): void;
+    /** Returns a promise that resolves to post the page visit in storage to Metroplex */
+    _getPostPageVisitPromise(): Promise<void>;
+}

package/dist/api/StoredPageVisit.js

@@ -1,5 +1,5 @@
 import { __awaiter } from 'tslib';
-import { SEVERITY, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, GET_METROPLEX_POST_URL } from '../constants.js';
+import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, GET_METROPLEX_POST_URL } from '../constants.js';
 import ClientConfig from './ClientConfig.js';
 import { stringifyJSON, postRequest } from '../utils/function.js';
 import Storage from '../storage/Storage.js';
@@ -7,6 +7,7 @@ import { Singleton } from '../monitors/BaseMonitor.js';
 import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
 import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
 import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
 // The local storage key used to store the last page visit
 const NOIBU_STORED_PAGE_VISIT = 'n_stored_page_visit';
@@ -83,7 +84,7 @@ class StoredPageVisit extends Singleton {
                     jsonSize: json.length,
                     storageSize: size,
                     diagnosis: yield storage.getDiagnoseInfo(),
-                }, false, SEVERITY.error);
+                }, false, Severity.ERROR);
             }
         });
     }
@@ -98,7 +99,7 @@ class StoredPageVisit extends Singleton {
                 msg: `Error parsing page visit string`,
                 data,
                 error,
-            }, false, SEVERITY.error);
+            }, false, Severity.ERROR);
             return null;
         });
     }

package/dist/const_matchers.d.ts

@@ -0,0 +1 @@
+export function WHITELIST_TEXT_REGEX_STRING(): string;