noibu-react-native 0.1.1 → 0.1.3

package/dist/api/clientConfig.d.ts

@@ -7,8 +7,8 @@ import { CustomerConfig, StoredConfig } from '../types/Config';
  * storing and retrieval.
  */
 export default class ClientConfig {
-    private readonly pageVisitId;
-    private browserId;
+    readonly pageVisitId: string;
+    browserId: StoredConfig['BrowserId'];
     private pageVisitSeq;
     private lastActiveTime;
     private readonly noibuErrorURL;
@@ -30,17 +30,16 @@ export default class ClientConfig {
     static configureInstance({ noibuErrorURL, customerConfig, }: {
         noibuErrorURL: string;
         customerConfig: CustomerConfig;
-    }): void;
+    }): Promise<void>;
     /**
      * gets the singleton instance
-     * @returns {ClientConfig}
      */
     static getInstance(): ClientConfig;
     /** lockClient will disable the client script for a single pagevisit for
      * duration given in minuntes */
     lockClient(duration: number, msg: string): Promise<void>;
     /** Locks the client until the next page loads */
-    lockClientUntilNextPage(msg: string): void;
+    lockClientUntilNextPage(msg: string): 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 */

package/dist/api/clientConfig.js

@@ -1,7 +1,9 @@
 import uuid from 'react-native-uuid';
-import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, SEVERITY, NOIBU_BROWSER_ID_KYWRD, PV_SEQ_NUM_RESET_TIME_MINUTES, JS_ENV, MAX_PAGEVISIT_VISITED, CLIENT_LOCK_TIME_MINUTES, GET_SCRIPT_ID, MAX_COLLECT_ERROR_LOG } from '../constants.js';
+import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, SEVERITY, NOIBU_BROWSER_ID_KYWRD, PV_SEQ_NUM_RESET_TIME_MINUTES, JS_ENV, MAX_PAGEVISIT_VISITED, CLIENT_LOCK_TIME_MINUTES, GET_SCRIPT_ID, GET_DEVICE_ENV, MAX_COLLECT_ERROR_LOG } from '../constants.js';
 import { stringifyJSON, getMaxSubstringAllowed, getUserAgent, makeRequest } from '../utils/function.js';
 import Storage from '../storage/storage.js';
+import { noibuLog } from '../utils/log.js';
+import { unwrapNoibuWrapped } from '../utils/object.js';
 
 /** @module ClientConfig */
 /**
@@ -42,8 +44,6 @@ class ClientConfig {
         this.lastActiveTime = new Date();
         // error URL to send Noibu errors to
         this.noibuErrorURL = noibuErrorURL;
-        // sets up this.browserId, this.isClientDisabled, this.pageVisitSeq
-        this._setupStorageVars();
         // error sent to backend counter
         this.cltErrorPostCounter = 0;
         // variables for checking if the socket is inactive
@@ -56,18 +56,16 @@ class ClientConfig {
         this.blockedElements = customerConfig.blockedElements;
     }
     /** Configures the singleton instance */
-    static configureInstance({ noibuErrorURL, customerConfig, }) {
+    static async configureInstance({ noibuErrorURL, customerConfig, }) {
         if (!this.instance) {
-            // Set this.noibuErrorURL preemptively in case ClientConfig isn't able to be
-            // configured properly and throws an error.
-            // This will ensure we get the expected error POST request at the correct URL.
             ClientConfig.noibuErrorURL = noibuErrorURL;
             this.instance = new ClientConfig(noibuErrorURL, customerConfig);
+            // sets up this.browserId, this.isClientDisabled, this.pageVisitSeq
+            await this.instance._setupStorageVars();
         }
     }
     /**
      * gets the singleton instance
-     * @returns {ClientConfig}
      */
     static getInstance() {
         if (!this.instance) {
@@ -84,11 +82,11 @@ class ClientConfig {
         noibuLSObject.DisabledStatus = true;
         noibuLSObject.ClientUnlockTime = expiryTime;
         await this._storeBrowserData(noibuLSObject);
-        this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+        await this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
     }
     /** Locks the client until the next page loads */
     lockClientUntilNextPage(msg) {
-        this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+        return this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
     }
     /**  Updates the config object to store the given last active time */
     async updateLastActiveTime(lastActiveTime) {
@@ -165,7 +163,7 @@ class ClientConfig {
     async _setupStorageVars() {
         const storage = Storage.getInstance();
         if (!(await storage.isAvailable())) {
-            this.postNoibuErrorAndOptionallyDisableClient(`Storage is unavailable, disabling client. ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
+            void this.postNoibuErrorAndOptionallyDisableClient(`Storage is unavailable, disabling client. ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
             return;
         }
         // getting the current content of the storage
@@ -175,6 +173,7 @@ class ClientConfig {
             noibuLSObject.CurrentPageVisitCount = 0;
         }
         this.browserId = noibuLSObject.BrowserId;
+        noibuLog('ClientConfig - _setupStorageVars', { noibuLSObject });
         this.pageVisitSeq = noibuLSObject.CurrentPageVisitCount;
         this.isClientDisabled = noibuLSObject.DisabledStatus;
         // If the client has been disabled just return.
@@ -199,7 +198,7 @@ class ClientConfig {
             // setting the lock time
             noibuLSObject.ClientUnlockTime = expiryTime;
             noibuLSObject.DisabledStatus = true;
-            this.postNoibuErrorAndOptionallyDisableClient(`Hit max page visits, disabling client for ${CLIENT_LOCK_TIME_MINUTES}mins`, true, SEVERITY.error);
+            await this.postNoibuErrorAndOptionallyDisableClient(`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 = await this._storeBrowserData(noibuLSObject);
@@ -207,7 +206,7 @@ class ClientConfig {
         // error happened, thus we disable collect.
         if (!savedData.BrowserId) {
             // we do not set a lock expiry date here since we cannot store to storage
-            this.postNoibuErrorAndOptionallyDisableClient(`Null browser in storage, disabling client`, true, SEVERITY.error);
+            void this.postNoibuErrorAndOptionallyDisableClient(`Null browser in storage, disabling client`, true, SEVERITY.error);
             this.browserId = '';
         }
     }
@@ -265,7 +264,7 @@ class ClientConfig {
             return data;
         }
         catch (e) {
-            this.postNoibuErrorAndOptionallyDisableClient(`Error writing browser data to storage, disabling client: ${e.message}, ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
+            await this.postNoibuErrorAndOptionallyDisableClient(`Error writing browser data to storage, disabling client: ${e.message}, ${await storage.getDiagnoseInfo()}`, true, SEVERITY.error);
             // sending empty fields if we encountered errors while storing in the LS
             return this._generateNewBrowserData();
         }
@@ -292,6 +291,12 @@ class ClientConfig {
      * severity expects one of the SEVERITY_x level constants, or else error will be used
      */
     async postNoibuErrorAndOptionallyDisableClient(errorMsg, disableClient, severity, keepAlive = false) {
+        noibuLog('postNoibuErrorAndOptionallyDisableClient', {
+            errorMsg,
+            disableClient,
+            severity,
+            keepAlive,
+        });
         if (this.isClientDisabled) {
             return;
         }
@@ -307,6 +312,7 @@ class ClientConfig {
             pageVisitId: this.pageVisitId,
             scriptId: GET_SCRIPT_ID(),
             ua: await getUserAgent(),
+            deviceEnv: GET_DEVICE_ENV(),
             error: errorMsg,
         };
         // if the page visits sends more errors than the
@@ -339,7 +345,7 @@ class ClientConfig {
             });
         }
         else {
-            fetch(this.noibuErrorURL, {
+            void unwrapNoibuWrapped(fetch)(this.noibuErrorURL, {
                 method: 'POST',
                 headers,
                 body: stringifyJSON(errorContent),

package/dist/api/inputManager.js

@@ -1,6 +1,6 @@
 import { NOIBUJS_SDK_REQUEST_HELP_CODE, NOIBUJS_SDK_ADD_ID_FUNCTION, NOIBUJS_SDK_ADD_ERROR_FUNCTION, NOIBUJS_SDK_ADD_ERROR_FROM_JS_FMW_FUNCTION, MAX_CUSTOM_ERRORS_PER_PAGEVISIT, MAX_CUSTOM_IDS_PER_PAGEVISIT, META_DATA_METROPLEX_TYPE, PAGE_VISIT_META_DATA_ATT_NAME, CUSTOM_ID_NAME_TYPE, CUSTOM_ID_VALUE_TYPE, CUSTOM_ERROR_EVENT_TYPE } from '../constants.js';
 import MetroplexSocket from './metroplexSocket.js';
-import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError/pageVisitEventError.js';
+import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
 import HelpCode from './helpCode.js';
 
 /** @module InputManager */

package/dist/api/metroplexSocket.d.ts

@@ -0,0 +1,155 @@
+/// <reference types="react-native" />
+/** Manages the socket to Metroplex */
+export default class MetroplexSocket {
+    _initialURL: string;
+    ackedOnce: boolean;
+    connectionCount: number;
+    connectionPromise: Promise<any> | null;
+    connectionURL: string;
+    currentConnectionAttempts: number;
+    forceClosed: boolean;
+    helpCodeCb: null | ((...args: any[]) => any);
+    initialReferingURL: string;
+    static instance: MetroplexSocket;
+    instanceId: string | number[];
+    isRetryLoopDisabled: boolean;
+    latestReceivedSeqNumStoredTime: Date;
+    latestReceivedSeqNumber: number;
+    messageSequenceNum: number;
+    metroRetryFrequencyMS: 30000;
+    metroplexTypeLock: Record<any, any>;
+    pageVisitInfoSent: boolean;
+    postURL: string;
+    previousMessageType: string;
+    retryMessageQueue: any[];
+    retryMetroplexInterval: null | number;
+    scriptInstanceId: string | number[] | undefined;
+    sessionLength: number;
+    sessionStartTime: any;
+    sessionTimestamp: Date;
+    socket: WebSocket | null;
+    socketInstanceId: string | number[] | null;
+    socketCloseCodes: string[];
+    socketOpens: string[];
+    /**
+     * Creates an instance of metroplex
+     * id of script, to make sure only a single socket is open
+     */
+    constructor(scriptInstanceId?: string | number[]);
+    /**
+     * gets the singleton instance
+     * @returns {MetroplexSocket}
+     */
+    static getInstance(scriptInstanceId?: string | number[]): MetroplexSocket;
+    /** Starts off the socket connection */
+    start(): void;
+    /**
+     * Adds the seq num field to the given payload depending on whether its
+     * a page visit part or video frag
+     */
+    _addSeqNumToPayload(type: string, payload: any): void;
+    /**
+     * sets the seq num in the payload for the given key and increments the
+     * global seq number
+     */
+    _setSeqNumInPayloadAndIncrementSeqNum(payloadKey: string, payload: any): void;
+    /** 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(type: string, payload: any): Promise<boolean>;
+    /** Updates the latest pv message sent timestamp if events contain any user steps
+     */
+    _updateLatestPvTimestamp(events: any[]): 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>;
+    /**
+     * connectSocket will establish a websocket connection to the metroplex
+     * service
+     */
+    connectSocket(): Promise<any> | null;
+    /** Calculates and sets the end_at field of the payload
+     * @param  {} payload
+     * @param  {} isPageVisit
+     */
+    addEndTimeToPayload(payload: any, isPageVisit: boolean): void;
+    /** open handler for socket */
+    _onSocketOpen(): Promise<void>;
+    /** message handler for socket
+     * @param  {} event
+     */
+    _onSocketMessage(event: any): Promise<void>;
+    /**
+     * Returns true if the message's payload has the payload type given and has a sequence
+     * number higher than seqNum
+     */
+    _messagePayloadHasLargerSeqNum(message: any, payloadType: string, seqNum: number): any;
+    /**
+     * 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;
+    /** sets up events that will trigger the event queue to be emptied */
+    _setupOffloadEvents(): 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: any): Promise<void>;
+    /**
+     * Stringifies the payload into JSON, sends it to the back end if the session
+     * is active and returns true. If inactive the session and socket are closed
+     * and this method returns false.
+     */
+    _sendSocketMessage(payload: any): Promise<void>;
+    /**
+     * Closes the socket connection if the session is inactive. Returns true if the
+     * session is inactive
+     */
+    closeIfInactive(): Promise<boolean>;
+    /** will get page information, calling this will increase the connection count */
+    getPageInformation(): Promise<{
+        br_id: string;
+        pv_id: string;
+        v: 5;
+        seq: number | null;
+        on_url: string;
+        ref_url: string;
+        start_at: string;
+        conc: number;
+        cv: 2;
+        last: boolean;
+        script_id: string;
+        script_inst_id: string | number[] | undefined;
+        mp_sock_inst_id: string | number[];
+        sock_inst_id: string | number[] | null;
+    }>;
+    /**
+     * Try to parse help code response and fire custom event
+     * @param {String} response
+     */
+    _tryProcessHelpCodeResponse(response: any): boolean;
+}