noibu-react-native 0.2.3 → 0.2.4

package/dist/monitors/{httpDataBundler.js → http-tools/HTTPDataBundler.js}

@@ -1,17 +1,19 @@
 import { __awaiter } from 'tslib';
-import { HUMAN_READABLE_CONTENT_TYPE_REGEX, DEFAULT_WEBSITE_SUBDOMAIN_PATTERN, SEVERITY, HTTP_BODY_NULL_STRING, HTTP_DATA_REQ_HEADERS_ATT_NAME, HTTP_DATA_PAYLOAD_ATT_NAME, HTTP_DATA_RESP_HEADERS_ATT_NAME, HTTP_DATA_RESP_PAYLOAD_ATT_NAME, HTTP_BODY_DROPPED_LENGTH_MSG, HTTP_BODY_DROPPED_TYPE_MSG, CONTENT_TYPE, CONTENT_LENGTH, BLOCKED_HTTP_HEADER_KEYS, PII_REDACTION_REPLACEMENT_STRING, MAX_HTTP_DATA_PAYLOAD_LENGTH, MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH } from '../constants.js';
-import ClientConfig from '../api/clientConfig.js';
-import StoredMetrics from '../api/storedMetrics.js';
-import { safeFromEntries, safeEntries } from '../utils/object.js';
-import { safeTrim, stringifyJSON, isString } from '../utils/function.js';
-import { removePII } from '../utils/piiRedactor.js';
+import { HUMAN_READABLE_CONTENT_TYPE_REGEX, DEFAULT_WEBSITE_SUBDOMAIN_PATTERN, SEVERITY, HTTP_BODY_NULL_STRING, HTTP_DATA_REQ_HEADERS_ATT_NAME, HTTP_DATA_PAYLOAD_ATT_NAME, HTTP_DATA_RESP_HEADERS_ATT_NAME, HTTP_DATA_RESP_PAYLOAD_ATT_NAME, HTTP_BODY_DROPPED_LENGTH_MSG, HTTP_BODY_DROPPED_TYPE_MSG, CONTENT_TYPE, CONTENT_LENGTH, BLOCKED_HTTP_HEADER_KEYS, PII_REDACTION_REPLACEMENT_STRING, MAX_HTTP_DATA_PAYLOAD_LENGTH, MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH } from '../../constants.js';
+import ClientConfig from '../../api/clientConfig.js';
+import StoredMetrics from '../../api/storedMetrics.js';
+import { safeFromEntries, safeEntries } from '../../utils/object.js';
+import { safeTrim, stringifyJSON, isString } from '../../utils/function.js';
+import { removePII } from '../../utils/piiRedactor.js';
+import { Singleton } from '../../types/Monitor.js';
 
 /** Bundles HTTP payloads and headers */
-class HTTPDataBundler {
+class HTTPDataBundler extends Singleton {
     /**
      * Creates an instance of the ClickMonitor instance
      */
     constructor() {
+        super();
         // compile regex only once
         this.contentTypeReadableRegex = new RegExp(HUMAN_READABLE_CONTENT_TYPE_REGEX, 'i');
         // pull out the domain hostname
@@ -43,15 +45,6 @@ class HTTPDataBundler {
         // TODO: disabled for beta. NOI-4253
         // this.uniqueRequests = new Set();
     }
-    /** gets the singleton instance
-     * @returns {HTTPDataBundler}
-     * */
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new HTTPDataBundler();
-        }
-        return this.instance;
-    }
     /**
      * Builds the HTTP payload allowed regexes for full and relative URLs
      * @param allowedURLs A list of allowed URLs
@@ -77,13 +70,12 @@ class HTTPDataBundler {
     }
     /**
      * Takes an iterator and returns a map of strings representing headers.
-     * @param {object} headersIterable any iterable object
-     * @returns a map of strings (as expected by metroplex) representing HTTP
+     * param {object} headersIterable any iterable object
+     * returns a map of strings (as expected by metroplex) representing HTTP
      * request or response headers
      */
     static headersMapFromIterable(headersIterable) {
         const headerMap = new Map();
-        // eslint-disable-next-line no-restricted-syntax
         for (const header of headersIterable) {
             // Ensure we're working with strings
             // This will also automatically convert null to "null"
@@ -153,65 +145,11 @@ class HTTPDataBundler {
             return null;
         });
     }
-    /**
-     * 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, isHostnameCheck = false) {
-        if (typeof requestURL !== 'string' ||
-            !this.initialURLPartsReversed ||
-            this.initialURLPartsReversed.length < 1) {
-            return false;
-        }
-        let requestHostname = isHostnameCheck ? requestURL : ''; // has to be declared outside of `try`
-        // Use URL constructor to extract hostname
-        if (!isHostnameCheck) {
-            try {
-                let requestURLWithProtocol = requestURL;
-                if (requestURL.startsWith('//')) {
-                    // eslint-disable-next-line prefer-template
-                    requestURLWithProtocol = 'https:' + requestURL;
-                }
-                requestHostname = new URL(requestURLWithProtocol).hostname;
-            }
-            catch (e) {
-                // Return false if URL() is unable to parse the request URL
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to determine hostname for request URL: ${e}`, false, SEVERITY.warn);
-                return false;
-            }
-        }
-        const requestParts = requestHostname.split('.');
-        // Remove first subdomain from either URL if it is www., www1., etc.
-        if (requestParts.length < 1)
-            return false;
-        /* eslint-disable no-unused-expressions */
-        DEFAULT_WEBSITE_SUBDOMAIN_PATTERN.test(requestParts[0]) &&
-            requestParts.shift();
-        /* eslint-enable no-unused-expressions */
-        // Reverse order array
-        requestParts.reverse();
-        if (!isHostnameCheck &&
-            requestParts.length < this.initialURLPartsReversed.length)
-            return false;
-        // Return true if for every part in the website part, the same part exists
-        // in the request part, or if alsoCheckSuperDomain is true.
-        if (isHostnameCheck) {
-            const isSubDomain = requestParts.length >= this.initialURLPartsReversed.length &&
-                this.initialURLPartsReversed.every((part, i) => part === requestParts[i]);
-            const isSuperDomain = requestParts.length <= this.initialURLPartsReversed.length &&
-                requestParts.every((part, i) => part === this.initialURLPartsReversed[i]);
-            return isSubDomain || isSuperDomain;
-        }
-        // Default return false if alsoCheckSuperDomain is not true
-        return this.initialURLPartsReversed.every((part, i) => part === requestParts[i]);
-    }
     /**
      * Builds an HTTP Data bundle
      */
     bundleHTTPData(url, requestHeaders, rawRequestPayload, responseHeaders, rawResponsePayload, method, isError) {
-        if (!this.isValidRequest(url, method)) {
+        if (!this.isValidRequest(method)) {
             return null;
         }
         // stringify payload if correct type and not too large
@@ -253,24 +191,9 @@ class HTTPDataBundler {
     /**
      * Validates a request based on the URL and method. When enabled, will handle
      * de-duping the requests
-     * @param {string} url
-     * @param {string} method
-     * @returns boolean indicating whether the validation passed
      */
-    isValidRequest(url, method) {
-        if (!this.httpDataCollectionEnabled)
-            return false;
-        if (!method || typeof method !== 'string') {
-            return false;
-        }
-        // TODO: Check below disabled for beta. NOI-4253
-        // only bundle and send once per request/method/response code combination
-        // const urlWithoutParams = url.split('?')[0];
-        // const requestSignature = `${urlWithoutParams}-${method}-${responseCode}`;
-        // if (this.uniqueRequests.has(requestSignature)) {
-        //   return false;
-        // }
-        return true;
+    isValidRequest(method) {
+        return (this.httpDataCollectionEnabled && method && typeof method === 'string');
     }
     /**
      * Checks two things: that the URL is either on the same domain (or an address relative to the
@@ -288,15 +211,15 @@ class HTTPDataBundler {
         // URL is absolute; either "http://example.com" or "//example.com"
         if (HTTPDataBundler.isAbsoluteURL(url)) {
             // Only capture requests on the same domain or in the allowed list
-            if (!this.isURLSameDomain(url) && !this.shouldCollectPayloadForURL(url))
+            if (!this.shouldCollectPayloadForURL(url)) {
                 return false;
+            }
         } // end `if` (if URL is relative, it is on the same domain.)
         return true;
     }
     /**
-     * Determins if the URL is absolute or relative
-     * @param {string} url
-     * @returns boolean indicating whether the URL passed is either absolute or relative
+     * Determines if the URL is absolute or relative
+     * returns boolean indicating whether the URL passed is either absolute or relative
      */
     static isAbsoluteURL(url) {
         if (!url || typeof url !== 'string') {
@@ -306,22 +229,20 @@ class HTTPDataBundler {
     }
     /**
      * Checks whether HTTP payloads can be collected on this URL
-     * @returns boolean indicating whether HTTP payloads can be collected on this URL
+     * returns boolean indicating whether HTTP payloads can be collected on this URL
      */
     shouldCollectPayloadForURL(url) {
+        var _a, _b;
         if (!url || typeof url !== 'string') {
             return false;
         }
         // check if in the full URL allowed list
-        const isAllowedAsAbsolute = !!this.httpDataAllowedAbsoluteRegex &&
-            this.httpDataAllowedAbsoluteRegex.test(url.toLowerCase());
-        const isRelative = !HTTPDataBundler.isAbsoluteURL(url) || this.isURLSameDomain(url);
+        const isAllowedAsAbsolute = (_a = this.httpDataAllowedAbsoluteRegex) === null || _a === void 0 ? void 0 : _a.test(url.toLowerCase());
+        const isRelative = !HTTPDataBundler.isAbsoluteURL(url);
         // check if in the relative URL allowed list or if it is on the same domain
         const isAllowedAsRelative = 
         // if this is a relative URL (isURLSameDomain will fail) OR a full URL on domain
-        isRelative &&
-            !!this.httpDataAllowedRelativeRegex &&
-            this.httpDataAllowedRelativeRegex.test(url.toLowerCase());
+        isRelative && ((_b = this.httpDataAllowedRelativeRegex) === null || _b === void 0 ? void 0 : _b.test(url.toLowerCase()));
         return isAllowedAsAbsolute || isAllowedAsRelative;
     }
     /**

package/dist/pageVisit/{eventDebouncer.js → EventDebouncer.js}

@@ -1,65 +1,54 @@
 import { PageVisit } from './pageVisit.js';
-import { LOCATION_EVENT_TYPE, TITLE_EVENT_TYPE, PAGE_TYPE_EVENT_TYPE, PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS, ERROR_EVENT_TYPE, HTTP_EVENT_TYPE, NETWORK_STATS_EVENT_TYPE, KEYBOARD_EVENT_TYPE, USERSTEP_EVENT_TYPE, ECOMMERCE_EVENT_TYPE, SEVERITY } from '../constants.js';
+import { APP_NAVIGATION_EVENT_TYPE, PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS, ERROR_EVENT_TYPE, HTTP_EVENT_TYPE, KEYBOARD_EVENT_TYPE, SEVERITY } from '../constants.js';
 import { timestampWrapper } from '../utils/date.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import ClientConfig from '../api/clientConfig.js';
+import { Singleton } from '../types/Monitor.js';
 
 /** @module EventDebouncer */
 /**
  * Singleton class responsible for debouncing all events
  * that are registered
  */
-class EventDebouncer {
+class EventDebouncer extends Singleton {
     /**
      * Creates an instance of EventDebouncer
      */
     constructor() {
-        // events are stored in queues that are debounced seperatly
-        // each object in this map is
-        // type: {
-        //   timeout: timeout,
-        //   events: [...],
-        //   debouncePeriod: period at which we debounce events,
-        //   eventName: name of the event, could be different than type
-        //      (clicks and keyboards are usersteps)
-        // }
-        this.eventsToDebounce = {};
-        // setting up debouncers for all events
-        // we send clicks directly to the socket so they aren't registered here
-        // we dont wait to send location changes, they happen at most once per second.
-        this.registerInputType(LOCATION_EVENT_TYPE, 0);
-        this.registerInputType(TITLE_EVENT_TYPE, 0);
-        this.registerInputType(PAGE_TYPE_EVENT_TYPE, 0);
-        this.registerInputType(PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-        this.registerInputType(ERROR_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-        this.registerInputType(HTTP_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-        this.registerInputType(NETWORK_STATS_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-        this.registerInputType(KEYBOARD_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS, USERSTEP_EVENT_TYPE);
-        this.registerInputType(ECOMMERCE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS);
-        this._setupUnloadHandler();
-    }
-    /**
-     * gets the instance of EventDebouncer
-     */
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new EventDebouncer();
-        }
-        return this.instance;
-    }
-    /** will debounce all events that are of this type by the debounce period
-     */
-    registerInputType(type, debouncePeriod, eventName = type) {
-        if (type in this.eventsToDebounce) {
-            return;
-        }
-        // registering this event type as a debouncable
-        this.eventsToDebounce[type] = {
-            timeout: null,
-            events: [],
-            debouncePeriod,
-            eventName,
+        super();
+        this.eventsToDebounce = {
+            [APP_NAVIGATION_EVENT_TYPE]: {
+                timeout: null,
+                events: [],
+                debouncePeriod: 0,
+                eventName: APP_NAVIGATION_EVENT_TYPE,
+            },
+            [PAGE_EVENT_TYPE]: {
+                timeout: null,
+                events: [],
+                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+                eventName: PAGE_EVENT_TYPE,
+            },
+            [ERROR_EVENT_TYPE]: {
+                timeout: null,
+                events: [],
+                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+                eventName: ERROR_EVENT_TYPE,
+            },
+            [HTTP_EVENT_TYPE]: {
+                timeout: null,
+                events: [],
+                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+                eventName: HTTP_EVENT_TYPE,
+            },
+            [KEYBOARD_EVENT_TYPE]: {
+                timeout: null,
+                events: [],
+                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+                eventName: KEYBOARD_EVENT_TYPE,
+            },
         };
+        this._setupUnloadHandler();
     }
     /**
      * Creates an event object with the event and the time it was added then pushes

package/dist/pageVisit/pageVisitEventError.js

@@ -1,8 +1,8 @@
 import { isValidURL, getJSStack, stringifyJSON, getMaxSubstringAllowed, asString } from '../utils/function.js';
-import { EVENT_ERROR_TYPE, URL_ATT_NAME, BLOCKLISTED_DOMAINS, ERROR_EVENT_TYPE, ERROR_EVENT_ERROR_TYPE, CUSTOM_ERROR_EVENT_TYPE, ERROR_EVENT_UNHANDLED_REJECTION_TYPE, ERROR_LOG_EVENT_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, WRAPPED_EXCEPTION_ERROR_TYPE, GQL_ERROR_TYPE, RESPONSE_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, ERROR_SOURCE_ATT_NAME, TYPE_ATT_NAME, JS_EVENT_TYPE, JS_ERROR_ATT_NAME, JS_STACK_FRAMES_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_METHOD_ATT_NAME, SEVERITY, JS_STACK_MESSAGE_ATT_NAME, HTTP_EVENT_TYPE, NOIBU_INPUT_URLS, HTTP_CODE_ATT_NAME, GQL_EVENT_TYPE, GQL_ERROR_ATT_NAME, PV_SEQ_ATT_NAME } from '../constants.js';
+import { EVENT_ERROR_TYPE, URL_ATT_NAME, BLOCKLISTED_DOMAINS, ERROR_EVENT_TYPE, ERROR_EVENT_ERROR_TYPE, CUSTOM_ERROR_EVENT_TYPE, ERROR_EVENT_UNHANDLED_REJECTION_TYPE, ERROR_LOG_EVENT_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, WRAPPED_EXCEPTION_ERROR_TYPE, GQL_ERROR_TYPE, RESPONSE_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, ERROR_SOURCE_ATT_NAME, TYPE_ATT_NAME, JS_EVENT_TYPE, JS_ERROR_ATT_NAME, JS_STACK_FRAMES_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_METHOD_ATT_NAME, SEVERITY, JS_STACK_MESSAGE_ATT_NAME, HTTP_EVENT_TYPE, NOIBU_INPUT_URLS, HTTP_CODE_ATT_NAME, PV_SEQ_ATT_NAME, GQL_EVENT_TYPE, GQL_ERROR_ATT_NAME } from '../constants.js';
 import ClientConfig from '../api/clientConfig.js';
-import { InputMonitor } from '../monitors/inputMonitor.js';
 import StoredMetrics from '../api/storedMetrics.js';
+import { EventDebouncer } from './EventDebouncer.js';
 
 /** @module PageVisitEventError */
 
@@ -314,7 +314,7 @@ function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
   // we register an error event
   StoredMetrics.getInstance().addError();
   // debounce event
-  InputMonitor.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
+  EventDebouncer.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
 }
 
 export { getOnURL, isErrorCollectedByNoibu, saveErrorToPagevisit };

package/dist/pageVisit/pageVisitEventHTTP.js

@@ -1,10 +1,10 @@
 import { timestampWrapper } from '../utils/date.js';
-import { HTTP_RESP_CODE_ATT_NAME, HTTP_RESP_TIME_ATT_NAME, HTTP_METHOD_ATT_NAME, URL_ATT_NAME, PV_SEQ_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, HTTP_EVENT_TYPE, MAX_HTTP_DATA_EVENT_COUNT, MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT, PAGE_VISIT_HTTP_DATA_ATT_NAME } from '../constants.js';
+import { HTTP_RESP_CODE_ATT_NAME, HTTP_RESP_TIME_ATT_NAME, HTTP_METHOD_ATT_NAME, URL_ATT_NAME, PV_SEQ_ATT_NAME, PAGE_VISIT_HTTP_DATA_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, HTTP_EVENT_TYPE, MAX_HTTP_DATA_EVENT_COUNT, MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT } from '../constants.js';
 import { PageVisit } from './pageVisit.js';
 import StoredMetrics from '../api/storedMetrics.js';
 import MetroplexSocket from '../api/metroplexSocket.js';
 import { getMaxSubstringAllowed, asString, safeTrim } from '../utils/function.js';
-import { EventDebouncer } from './eventDebouncer.js';
+import { EventDebouncer } from './EventDebouncer.js';
 
 /** @module PageVisitEventHTTP */
 /**
@@ -54,8 +54,9 @@ class PageVisitEventHTTP {
                 this.httpEvent[PV_SEQ_ATT_NAME] = sequenceNumber;
                 // increment the count
                 StoredMetrics.getInstance().addHttpData();
-                const metroplexMsg = {};
-                metroplexMsg[PAGE_VISIT_HTTP_DATA_ATT_NAME] = this.httpData;
+                const metroplexMsg = {
+                    [PAGE_VISIT_HTTP_DATA_ATT_NAME]: this.httpData,
+                };
                 MetroplexSocket.getInstance().sendMessage(HTTP_DATA_METROPLEX_TYPE, metroplexMsg);
             }
             else {

package/dist/sessionRecorder/sessionRecorder.js

@@ -4,7 +4,7 @@ import { LogLevel, initialize, subscribeToNativeEvent } from './nativeSessionRec
 import StoredMetrics from '../api/storedMetrics.js';
 import ClientConfig from '../api/clientConfig.js';
 import { stringifyJSON } from '../utils/function.js';
-import { SEVERITY, POST_METRICS_EVENT_NAME, MAX_TIME_FOR_RECORDER_USER_EVENTS, MAX_RECORDER_EVENT_BUFFER, MAX_TIME_FOR_UNSENT_DATA_MILLIS, VIDEO_FRAG_ATT_NAME, PV_SEQ_ATT_NAME, LENGTH_ATT_NAME, CSS_URLS_ATT_NAME, VIDEO_METROPLEX_TYPE, PAGE_VISIT_VID_FRAG_ATT_NAME } from '../constants.js';
+import { MAX_TIME_FOR_RECORDER_USER_EVENTS, SEVERITY, MAX_RECORDER_EVENT_BUFFER, MAX_TIME_FOR_UNSENT_DATA_MILLIS, VIDEO_FRAG_ATT_NAME, PV_SEQ_ATT_NAME, LENGTH_ATT_NAME, CSS_URLS_ATT_NAME, VIDEO_METROPLEX_TYPE, PAGE_VISIT_VID_FRAG_ATT_NAME, POST_METRICS_EVENT_NAME } from '../constants.js';
 import MetroplexSocket from '../api/metroplexSocket.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { noibuLog } from '../utils/log.js';

package/dist/src/api/clientConfig.d.ts

@@ -43,7 +43,7 @@ export default class ClientConfig {
     /**  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>;
+    getPageVisitSeq(): Promise<number>;
     /**
      *  Returns the client config object from storage or generates a new one
      * What is stored in storage will look like this

package/dist/src/api/helpCode.d.ts

@@ -1,23 +1,13 @@
+import { Singleton } from '../../types/Monitor';
 /**
  * HelpCode class is responsible for help code feature related functionality
  */
-export default class HelpCode {
+export default class HelpCode extends Singleton {
+    private requestContext;
     /**
-     * Singleton instance
-     * @returns {HelpCode}
+     * Constructs instance and sets up event listeners
      */
-    static getInstance(): HelpCode;
-    requestContext: {
-        resolve: null;
-        reject: null;
-        promise: null;
-    } | null;
-    /**
-     * Handles the received help code event.
-     * @param {CustomEvent<string>} event - The event object with string detail property.
-     * @returns {void}
-     */
-    receiveHelpCode(event: CustomEvent<string>): void;
+    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.
@@ -25,5 +15,9 @@ export default class HelpCode {
      * @returns {Promise<string>} Promise object representing the help code request.
      * @throws {string} Throws an error if the noibu connection is unavailable.
      */
-    requestHelpCode(): Promise<string>;
+    requestHelpCode(): Promise<unknown>;
+    /**
+     * Handles the received help code event.
+     */
+    receiveHelpCode(event: CustomEvent<string>): void;
 }

package/dist/src/api/metroplexSocket.d.ts

@@ -1,67 +1,67 @@
-import { END_AT_ATT_NAME } from '../constants';
+import { PAGE_VISIT_PART_ATT_NAME, PAGE_VISIT_VID_FRAG_ATT_NAME } from '../constants';
+import { Singleton } from '../../types/Monitor';
+import { CompletePageVisit, InboundMessageType, OutboundMessageType, OutboundMessageTypeMap, PageVisitFrag, PageVisitInfo, SlidingMessage, VideoFrag } from '../../types/Metroplex.types';
+import { PVEventMessage } from '../../types/PageVisitEvents.types';
+/**
+ * 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 {
-    _initialURL: any;
-    ackedOnce: any;
-    connectionCount: any;
-    connectionPromise: Promise<any>;
-    connectionURL: any;
-    currentConnectionAttempts: any;
-    forceClosed: any;
-    helpCodeCb: null | ((...args: any[]) => any);
-    initialReferingURL: any;
-    static instance: MetroplexSocket;
-    instanceId: any;
-    isRetryLoopDisabled: any;
-    latestReceivedSeqNumStoredTime: any;
-    latestReceivedSeqNumber: any;
-    messageSequenceNum: any;
-    metroRetryFrequencyMS: any;
-    metroplexTypeLock: Record<any, any>;
-    pageVisitInfoSent: any;
-    postURL: any;
-    previousMessageType: any;
-    retryMessageQueue: any[];
-    retryMetroplexInterval: null | number;
-    scriptInstanceId: any;
-    sessionLength: any;
-    sessionStartTime: any;
-    sessionTimestamp: any;
+export default class MetroplexSocket extends Singleton {
+    forceClosed: boolean;
     socket: WebSocket | null;
-    socketInstanceId: string | number[] | null;
+    socketInstanceId: string | null;
+    previousMessageType: string;
+    currentConnectionAttempts: number;
+    connectionCount: number;
+    sessionStartTime: any;
+    connectionPromise: Promise<void> | null;
+    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: SlidingMessage<keyof OutboundMessageTypeMap>[];
+    metroplexTypeLock: Record<OutboundMessageType, boolean>;
+    initialURL: string;
+    initialReferringURL: string;
+    sessionTimestamp: Date;
+    latestReceivedSeqNumStoredTime: Date;
+    instanceId: string;
+    scriptInstanceId?: string;
+    sessionLength: number;
     socketCloseCodes: string[];
     socketOpens: string[];
+    ackedOnce: boolean;
+    metroRetryFrequencyMS: 30000;
+    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 | number[]);
-    /**
-     * gets the singleton instance
-     * @returns {MetroplexSocket}
-     */
-    static getInstance(scriptInstanceId?: string | number[]): MetroplexSocket;
+    constructor(scriptInstanceId?: string);
+    private static readonly typeToPayloadPropMap;
     /**
      * 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;
+    _addSeqNumToPayload<T>(type: OutboundMessageType, payload: T): T;
     /** requests help code and saves a callback to be called on response */
-    requestHelpCode(cb: (typeof this)['helpCodeCb']): Promise<boolean>;
+    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>;
+    sendMessage<T extends OutboundMessageType>(type: T, payload: OutboundMessageTypeMap[T]): Promise<boolean>;
     /** Updates the latest pv message sent timestamp if events contain any user steps
      */
-    _updateLatestPvTimestamp(events: any[]): Promise<void>;
+    _updateLatestPvTimestamp(events: PVEventMessage[]): 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 */
@@ -75,25 +75,23 @@ export default class MetroplexSocket {
      * connectSocket will establish a websocket connection to the metroplex
      * service
      */
-    connectSocket(): Promise<any>;
+    connectSocket(): Promise<void>;
     /** Calculates and sets the end_at field of the payload
      * @param  {} payload
      * @param  {} isPageVisit
      */
-    addEndTimeToPayload(payload: any, isPageVisit: boolean): typeof payload & {
-        [END_AT_ATT_NAME]: string;
-    };
+    addEndTimeToPayload<T extends VideoFrag | PageVisitFrag>(payload: T, isPageVisit: boolean): T;
     /** open handler for socket */
     _onSocketOpen(): Promise<void>;
     /** message handler for socket
      * @param  {} event
      */
-    _onSocketMessage(event: any): Promise<void>;
+    _onSocketMessage(event: InboundMessageType): 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;
+    _messagePayloadHasLargerSeqNum(message: SlidingMessage, payloadType: typeof PAGE_VISIT_PART_ATT_NAME | typeof PAGE_VISIT_VID_FRAG_ATT_NAME, seqNum: number): boolean;
     /**
      * removes messages from the retry queue that are smaller than the
      * latest stored message in metroplex
@@ -118,39 +116,22 @@ export default class MetroplexSocket {
     /**
      * will send a message to metroplex via a post request that will outlive the current page
      */
-    postMessage(msg: any): Promise<void>;
+    postMessage(msg: CompletePageVisit): 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>;
+    _sendSocketMessage<T extends ValueOf<OutboundMessageTypeMap>>(payload: T): 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: any;
-        ref_url: any;
-        start_at: any;
-        conc: any;
-        cv: 2;
-        last: boolean;
-        script_id: string;
-        script_inst_id: any;
-        mp_sock_inst_id: any;
-        sock_inst_id: string | number[] | null;
-        video_recorder: string;
-    }>;
+    getPageInformation(): Promise<PageVisitInfo>;
     /**
      * Try to parse help code response and fire custom event
-     * @param {String} response
      */
-    _tryProcessHelpCodeResponse(response: any): boolean;
+    _tryProcessHelpCodeResponse(response: unknown): boolean;
 }

package/dist/src/api/storedPageVisit.d.ts

@@ -1,39 +1,30 @@
+import { Singleton } from '../../types/Monitor';
+import { CompletePageVisit, PageVisitFrag, PageVisitInfo, SlidingMessage } from '../../types/Metroplex.types';
 /**
  * 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 {
-    /** gets the singleton instance */
-    static getInstance(): StoredPageVisit;
-    latestPageVisitFrag: any;
-    writeTimeout: any;
-    flushedStorage: boolean;
+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
-     * @param  {} retryMessageQueue
-     * @param  {} pvInfo
      */
-    checkAndStoreRetryQueue(retryMessageQueue: any, pvInfo: any): void;
+    checkAndStoreRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
     /** Writes the page visit frags in the retry queue to storage
-     * @param  {} retryMessageQueue
-     * @param  {} pvInfo
      */
-    writePageVisitsFromRetryQueue(retryMessageQueue: any, pvInfo: any): void;
+    writePageVisitsFromRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
     /** Write the given page visit frags to storage
-     * @param  {} pageVisitFrags
-     * @param  {} pvInfo
      */
-    _writePageVisitFrags(pageVisitFrags: any, pvInfo: any): Promise<void>;
+    _writePageVisitFrags(pageVisitFrags: PageVisitFrag[], pvInfo: PageVisitInfo): Promise<void>;
     /**
      * Read the stored page visit from storage, create a complete page visit object
      * and then post that to Metroplex
      */
-    _getPostData(): Promise<{
-        pvi: any;
-        pvp: never[];
-        pvvf: never[];
-    } | null>;
+    _getPostData(): Promise<CompletePageVisit>;
     /**
      * Creates and tries to resolve a promise that posts the previous page visit
      * to Metroplex from storage
@@ -45,5 +36,5 @@ export default class StoredPageVisit {
      */
     _updateStorageFlushed(): void;
     /** Returns a promise that resolves to post the page visit in storage to Metroplex */
-    _getPostPageVisitPromise(): Promise<any>;
+    _getPostPageVisitPromise(): Promise<void>;
 }