noibu-react-native 0.2.3 → 0.2.5

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 '../BaseMonitor.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 '../monitors/BaseMonitor.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/nativeSessionRecorderSubscription.js

@@ -46,13 +46,30 @@ function initialize(projectId, config) {
     const refinedMaximumDailyNetworkUsageInMB = maximumDailyNetworkUsageInMB !== null && maximumDailyNetworkUsageInMB !== void 0 ? maximumDailyNetworkUsageInMB : 0;
     NativeSessionRecorder.initialize(projectId, userId, logLevel, allowMeteredNetworkUsage, enableWebViewCapture, allowedDomains, disableOnLowEndDevices, enableDailyNetworkUsageLimit, refinedMaximumDailyNetworkUsageInMB);
 }
+/**
+ * Subscribes to a native event emitted by the Noibu Session Recorder.
+ *
+ * This function listens for the `noibuRecordingEvent` emitted from the native layer (only on Android)
+ * and invokes the provided callback whenever the event occurs. If the platform is not Android,
+ * the function will do nothing and return a no-op unsubscribe function.
+ *
+ * @param {function(RecorderEvent): void} callback - A callback function that will be invoked with
+ * the event data whenever the `noibuRecordingEvent` is emitted.
+ *
+ * @returns {UnsubscribeFn} A function to unsubscribe from the event. On Android, this will remove
+ * the event listener. On other platforms, it will be a no-op.
+ *
+ * @throws {Error} If the Noibu Session Recorder is not initialized before calling this function.
+ */
 function subscribeToNativeEvent(callback) {
-    if (!nativeModuleEmitter) {
-        throw new Error('You have to initialize Noibu Session Recorder first');
+    if (Platform.OS === 'android') {
+        if (!nativeModuleEmitter) {
+            throw new Error('You have to initialize Noibu Session Recorder first');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        nativeModuleEmitter.addListener('noibuRecordingEvent', callback);
+        // return () => subscription.remove();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    nativeModuleEmitter.addListener('noibuRecordingEvent', callback);
-    // return () => subscription.remove();
     return () => { };
 }
 

package/dist/sessionRecorder/sessionRecorder.js

@@ -4,10 +4,11 @@ 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';
+import { Platform } from 'react-native';
 
 /** Singleton class to record user sessions */
 class SessionRecorder {
@@ -36,7 +37,9 @@ class SessionRecorder {
             const nativeSessionRecorderConfig = {
                 logLevel: LogLevel.Verbose,
             };
-            initialize('abc1234', nativeSessionRecorderConfig);
+            if (Platform.OS === 'android') {
+                initialize('abc1234', nativeSessionRecorderConfig);
+            }
             this.instance = new SessionRecorder();
             // todo handle RN clicks
             addSafeEventListener(window, 'click', () => {

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

@@ -1,12 +1,13 @@
 import { SEVERITY } from '../constants';
 import { CustomerConfig, StoredConfig } from '../../types/Config';
+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 {
+export default class ClientConfig extends Singleton {
     readonly pageVisitId: string;
     browserId: StoredConfig['BrowserId'];
     private pageVisitSeq;
@@ -15,26 +16,20 @@ export default class ClientConfig {
     private cltErrorPostCounter;
     private readonly maxSocketInactiveTime;
     private locationBreadcrumbs;
-    private static instance;
-    static noibuErrorURL: string;
     customerDomain: string;
     isClientDisabled: boolean;
+    configurationPromise: Promise<void>;
     readonly listOfUrlsToCollectHttpDataFrom: CustomerConfig['listOfUrlsToCollectHttpDataFrom'];
     readonly enableHttpDataCollection: CustomerConfig['enableHttpDataCollection'];
     readonly blockedElements: CustomerConfig['blockedElements'];
     /**
      * Creates a ClientConfig singleton instance
      */
-    constructor(noibuErrorURL: string, customerConfig: CustomerConfig);
-    /** Configures the singleton instance */
-    static configureInstance({ noibuErrorURL, customerConfig, }: {
-        noibuErrorURL: string;
-        customerConfig: CustomerConfig;
-    }): Promise<void>;
+    constructor(noibuErrorURL?: string, customerConfig?: CustomerConfig);
     /**
-     * gets the singleton instance
+     * Convenience method to check correct setup
      */
-    static getInstance(): ClientConfig;
+    private hasAllNecessaryArgs;
     /** lockClient will disable the client script for a single pagevisit for
      * duration given in minuntes */
     lockClient(duration: number, msg: string): Promise<void>;
@@ -43,7 +38,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
@@ -97,7 +92,7 @@ export default class ClientConfig {
      * and disable the client if required
      * severity expects one of the SEVERITY_x level constants, or else error will be used
      */
-    postNoibuErrorAndOptionallyDisableClient(errorMsg: any, disableClient: boolean, severity: (typeof SEVERITY)[keyof typeof SEVERITY], keepAlive?: boolean): Promise<void>;
+    postNoibuErrorAndOptionallyDisableClient(errorMsg: any, disableClient?: boolean, severity?: (typeof SEVERITY)[keyof typeof SEVERITY], keepAlive?: boolean): Promise<void>;
     /**
      * Returns true if the page visit is considered to be inactive
      */

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

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

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

@@ -1,23 +1,13 @@
+import { Singleton } from '../monitors/BaseMonitor';
 /**
  * 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;
 }