noibu-react-native 0.2.6 → 0.2.7

package/README.md

@@ -27,7 +27,8 @@ Install using favourite node package manager (npm, yarn, etc.):
 npm install noibu-react-native --save
 ```
 
-Additionally, for iOS target do: 
+Additionally, for iOS target do:
+
 ```bash
 npx pod-install
 ```
@@ -65,22 +66,21 @@ That's it! First time the module is set up, it runs an init and starts listening
 ## Configuration
 
 `setupNoibu(config): void` method accepts following parameters:
- - `config` which consists of
-   - `@property domain {string}` - indicates which Noibu dashboard session recordings should go to ([learn more about domains](https://help.noibu.com/hc/en-us/articles/4846518088845-Domains-Overview))
-   - `@property [blockedElements] {string[]}` - lets you specify component ids to be ignored by SDK when collecting error information
-   - `@property [enableHttpDataCollection] {boolean}` - indicates whether SDK should collect HTTP information like headers or body from requests
-   - `@property [listOfUrlsToCollectHttpDataFrom] {string[]}` - is an allow list of URLs to allow HTTP data collection from, works best with `enableHttpDataCollection` enabled
 
-Example: 
+- `config` which consists of
+  - `@property domain {string}` - indicates which Noibu dashboard session recordings should go to ([learn more about domains](https://help.noibu.com/hc/en-us/articles/4846518088845-Domains-Overview))
+  - `@property [blockedElements] {string[]}` - lets you specify component ids to be ignored by SDK when collecting error information
+  - `@property [enableHttpDataCollection] {boolean}` - indicates whether SDK should collect HTTP information like headers or body from requests
+  - `@property [listOfUrlsToCollectHttpDataFrom] {string[]}` - is an allow list of URLs to allow HTTP data collection from, works best with `enableHttpDataCollection` enabled
+
+Example:
+
 ```js
 setupNoibu({
-   domain: 'react-native-app.myshop.com',
-   enableHttpDataCollection: true,
-   listOfUrlsToCollectHttpDataFrom: [
-      'https://react-native-app.myshop.com/backend',
-      'https://example.com/some-path/',
-   ],
-   blockedElements: ['sensitive-info']
+  domain: 'react-native-app.myshop.com',
+  enableHttpDataCollection: true,
+  listOfUrlsToCollectHttpDataFrom: ['https://react-native-app.myshop.com/backend', 'https://example.com/some-path/'],
+  blockedElements: ['sensitive-info'],
 });
 ```
 
@@ -101,7 +101,7 @@ Requests a help code from the HelpCode instance. To read more about help codes,
 ```jsx
 import { NoibuJS } from 'noibu-react-native';
 import { useCallback, useState } from 'react';
-import { Alert, Text, Pressable, View} from 'react-native';
+import { Alert, Text, Pressable, View } from 'react-native';
 
 const AlertHelpCode = () => {
   const triggerHelpCodeAlert = useCallback(async () => {

package/dist/api/{clientConfig.js → ClientConfig.js}

@@ -1,12 +1,22 @@
 import { __awaiter } from 'tslib';
 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, 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 { SEVERITY, 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 { unwrapNoibuWrapped } from '../utils/object.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
 
+// maximum number of page visits assigned to a single browser id
+const MAX_PAGEVISIT_VISITED = 300;
+// The amount of time to lock the client for if they have exceeded things
+// like the maximum number of pagevisits
+const CLIENT_LOCK_TIME_MINUTES = 45;
+// The amount of inactive time required for us to reset the page visit sequence numbers
+const PV_SEQ_NUM_RESET_TIME_MINUTES = 45;
+// number of errors that collect can send to metroplex before shutting himself off.
+const MAX_COLLECT_ERROR_LOG = 50;
+const NOIBU_BROWSER_ID_KYWRD = 'n_browser_data';
 /**
  * Singleton class to manage the client configuration
  * this class will be responsible for controlling the disabled
@@ -14,9 +24,18 @@ import { Singleton } from '../monitors/BaseMonitor.js';
  * storing and retrieval.
  */
 class ClientConfig extends Singleton {
-    /**
-     * Creates a ClientConfig singleton instance
-     */
+    /**  Error handling for constructor */
+    handleConstructorError(noibuErrorURL, customerConfig) {
+        const reason = {
+            msg: 'ClientConfig was not properly configured',
+            noibuErrorURL,
+            customerConfig,
+            globalUrl: this.globalUrl,
+        };
+        void this.postInternalError(reason, true, SEVERITY.error);
+        this.configurationPromise = Promise.reject(reason);
+    }
+    /** Creates a ClientConfig singleton instance */
     constructor(noibuErrorURL, customerConfig) {
         super();
         this.pageVisitId = uuid.v4();
@@ -33,26 +52,25 @@ class ClientConfig extends Singleton {
         this.maxSocketInactiveTime = MAX_METROPLEX_SOCKET_INNACTIVE_TIME;
         this.locationBreadcrumbs = [];
         this.isClientDisabled = false;
+        if (!noibuErrorURL || !customerConfig) {
+            this.handleConstructorError(noibuErrorURL, customerConfig);
+            return;
+        }
         this.noibuErrorURL = noibuErrorURL;
         this.customerDomain = customerConfig.domain;
-        this.listOfUrlsToCollectHttpDataFrom =
-            customerConfig.listOfUrlsToCollectHttpDataFrom;
-        this.enableHttpDataCollection = customerConfig.enableHttpDataCollection;
-        this.blockedElements = customerConfig.blockedElements;
-        if (!noibuErrorURL || !this.hasAllNecessaryArgs()) {
-            const reason = Object.assign({ msg: 'ClientConfig was not properly configured' }, customerConfig);
-            void this.postNoibuErrorAndOptionallyDisableClient(reason, true, SEVERITY.error);
-            this.configurationPromise = Promise.reject(reason);
+        if (!this.hasAllNecessaryArgs(customerConfig)) {
+            this.handleConstructorError(noibuErrorURL, customerConfig);
             return;
         }
+        this.listOfUrlsToCollectHttpDataFrom = customerConfig.listOfUrlsToCollectHttpDataFrom;
+        this.enableHttpDataCollection = customerConfig.enableHttpDataCollection;
+        this.blockedElements = customerConfig.blockedElements;
         // sets up this.browserId, this.isClientDisabled, this.pageVisitSeq
         this.configurationPromise = this._setupStorageVars();
     }
-    /**
-     * Convenience method to check correct setup
-     */
-    hasAllNecessaryArgs() {
-        return (!!this.customerDomain && this.globalUrl.includes(this.customerDomain));
+    /** Convenience method to check correct setup */
+    hasAllNecessaryArgs(customerConfig) {
+        return !!customerConfig.domain && this.globalUrl.includes(customerConfig.domain);
     }
     /** lockClient will disable the client script for a single pagevisit for
      * duration given in minuntes */
@@ -64,12 +82,12 @@ class ClientConfig extends Singleton {
             noibuLSObject.DisabledStatus = true;
             noibuLSObject.ClientUnlockTime = expiryTime;
             yield this._storeBrowserData(noibuLSObject);
-            yield this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+            yield this.postInternalError(msg, true, SEVERITY.warn);
         });
     }
     /** Locks the client until the next page loads */
     lockClientUntilNextPage(msg) {
-        return this.postNoibuErrorAndOptionallyDisableClient(msg, true, SEVERITY.warn);
+        return this.postInternalError(msg, true, SEVERITY.warn);
     }
     /**  Updates the config object to store the given last active time */
     updateLastActiveTime(lastActiveTime) {
@@ -133,9 +151,7 @@ class ClientConfig extends Singleton {
             return parsedConfig;
         });
     }
-    /**
-     * Check if we have surpassed the last active time and the page visit seq number needs resetting
-     */
+    /** Check if we have surpassed the last active time and the page visit seq number needs resetting */
     _pageVisitSeqNeedsReset() {
         return __awaiter(this, void 0, void 0, function* () {
             const noibuLSObject = yield this._getClientState();
@@ -155,7 +171,7 @@ class ClientConfig extends Singleton {
         return __awaiter(this, void 0, void 0, function* () {
             const storage = Storage.getInstance();
             if (!(yield storage.isAvailable())) {
-                void this.postNoibuErrorAndOptionallyDisableClient(`Storage is unavailable, disabling client. ${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
@@ -175,11 +191,6 @@ class ClientConfig extends Singleton {
             // Update the LS object values before storing it for the next page visit
             noibuLSObject.CurrentPageVisitCount += 1;
             noibuLSObject.LastActive = new Date();
-            // Expose page visit ID in storage for use by Trailbreaker video tests
-            // This will be done for the testvideo and lambdavideo bundles used by Trailbreaker
-            if (JS_ENV().includes('video')) {
-                noibuLSObject.pvId = this.pageVisitId;
-            }
             // if we have reached the max page visits for a browser id then
             // we disabled collect for 45 minutes
             if (noibuLSObject.CurrentPageVisitCount >= MAX_PAGEVISIT_VISITED) {
@@ -190,7 +201,7 @@ class ClientConfig extends Singleton {
                 // setting the lock time
                 noibuLSObject.ClientUnlockTime = expiryTime;
                 noibuLSObject.DisabledStatus = true;
-                yield this.postNoibuErrorAndOptionallyDisableClient(`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);
@@ -198,7 +209,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.postNoibuErrorAndOptionallyDisableClient(`Null browser in storage, disabling client`, true, SEVERITY.error);
+                void this.postInternalError({ msg: `Null browser in storage, disabling client` }, true, SEVERITY.error);
                 this.browserId = '';
             }
         });
@@ -213,8 +224,7 @@ class ClientConfig extends Singleton {
         return __awaiter(this, void 0, void 0, function* () {
             const newConfigData = yield this._getLsObject();
             // if the lock expired, we remove the lock period and enable the client
-            if (newConfigData.ClientUnlockTime &&
-                new Date(newConfigData.ClientUnlockTime) <= new Date()) {
+            if (newConfigData.ClientUnlockTime && new Date(newConfigData.ClientUnlockTime) <= new Date()) {
                 newConfigData.ClientUnlockTime = undefined;
                 newConfigData.DisabledStatus = false;
                 yield this._storeBrowserData(newConfigData);
@@ -237,18 +247,12 @@ class ClientConfig extends Singleton {
      *   and persisted throughout a session
      */
     _generateNewBrowserData() {
-        const noibuBrowserData = {
+        return {
             DisabledStatus: false,
             BrowserId: uuid.v4(),
             CurrentPageVisitCount: 0,
             LastActive: new Date(),
         };
-        // Expose page visit ID in storage for use by Trailbreaker video tests
-        // This will be done for the testvideo and lambdavideo bundles used by Trailbreaker
-        if (JS_ENV().includes('video')) {
-            noibuBrowserData.pvId = this.pageVisitId;
-        }
-        return noibuBrowserData;
     }
     /**
      * _storeBrowserData will store the passed object in storage.
@@ -262,7 +266,10 @@ class ClientConfig extends Singleton {
                 return data;
             }
             catch (e) {
-                yield this.postNoibuErrorAndOptionallyDisableClient(`Error writing browser data to storage, disabling client: ${e.message}, ${yield storage.getDiagnoseInfo()}`, true, SEVERITY.error);
+                yield this.postInternalError({
+                    msg: 'Error writing browser data to storage, disabling client: ' + e.message,
+                    diagnosis: yield storage.getDiagnoseInfo(),
+                }, true, SEVERITY.error);
                 // sending empty fields if we encountered errors while storing in the LS
                 return this._generateNewBrowserData();
             }
@@ -285,13 +292,13 @@ class ClientConfig extends Singleton {
         return getMaxSubstringAllowed(globalUrl.toString());
     }
     /**
-     * postNoibuErrorAndOptionallyDisableClient will post errors that were thrown by collect
+     * 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
      */
-    postNoibuErrorAndOptionallyDisableClient(errorMsg_1) {
+    postInternalError(errorMsg_1) {
         return __awaiter(this, arguments, void 0, function* (errorMsg, disableClient = false, severity = SEVERITY.error, keepAlive = false) {
-            noibuLog('postNoibuErrorAndOptionallyDisableClient', {
+            noibuErr('postInternalError', {
                 errorMsg,
                 disableClient,
                 severity,
@@ -313,7 +320,7 @@ class ClientConfig extends Singleton {
                 scriptId: GET_SCRIPT_ID(),
                 ua: yield getUserAgent(),
                 deviceEnv: GET_DEVICE_ENV(),
-                error: stringifyJSON(errorMsg),
+                msg: stringifyJSON(errorMsg),
             };
             // if the page visits sends more errors than the
             // allowed threshold we disable the client
@@ -329,7 +336,7 @@ class ClientConfig extends Singleton {
                 this.isClientDisabled = true;
                 // end of lock
                 // overriding the message to be an alert that we are shutting collect off.
-                collectError.error = `Shutting collect off, we reached the maximum limit of collect errors sent.`;
+                collectError.msg = `Shutting collect off, we reached the maximum limit of collect errors sent.`;
             }
             const errorContent = {
                 url: this.globalUrl,
@@ -340,7 +347,7 @@ class ClientConfig extends Singleton {
                 'content-type': 'application/json',
             };
             if (!keepAlive) {
-                makeRequest('POST', this.noibuErrorURL, errorContent, headers, 2000, false).catch(() => {
+                postRequest(this.noibuErrorURL, errorContent, headers, false, 2000).catch(() => {
                     // we do nothing and let this error silently fail
                 });
             }
@@ -359,14 +366,24 @@ class ClientConfig extends Singleton {
             }
         });
     }
-    /**
-     * Returns true if the page visit is considered to be inactive
-     */
+    /** Returns true if the page visit is considered to be inactive */
     isInactive() {
         const someTimeAgo = new Date();
         someTimeAgo.setSeconds(someTimeAgo.getSeconds() - this.maxSocketInactiveTime);
         return this.lastActiveTime < someTimeAgo;
     }
+    /**
+     * 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, fun) {
+        try {
+            fun();
+        }
+        catch (error) {
+            this.postInternalError({ msg: `Error in ${explanation}`, error }, false, SEVERITY.error);
+        }
+    }
 }
 
 export { ClientConfig as default };

package/dist/api/{helpCode.js → HelpCode.js}

@@ -1,16 +1,14 @@
 import { __awaiter } from 'tslib';
-import MetroplexSocket from './metroplexSocket.js';
+import MetroplexSocket from './MetroplexSocket.js';
 import { SEVERITY } from '../constants.js';
-import ClientConfig from './clientConfig.js';
+import ClientConfig from './ClientConfig.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
 
 /**
  * HelpCode class is responsible for help code feature related functionality
  */
 class HelpCode extends Singleton {
-    /**
-     * Constructs instance and sets up event listeners
-     */
+    /** Constructs instance and sets up event listeners */
     constructor() {
         super();
         this.requestContext = null;
@@ -19,9 +17,6 @@ class HelpCode extends Singleton {
     /**
      * Requests a help code and returns a Promise that resolves when the help code is obtained
      * or rejects if the noibu connection is unavailable.
-  
-     * @returns {Promise<string>} Promise object representing the help code request.
-     * @throws {string} Throws an error if the noibu connection is unavailable.
      */
     requestHelpCode() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -46,16 +41,14 @@ class HelpCode extends Singleton {
             return this.requestContext.promise;
         });
     }
-    /**
-     * Handles the received help code event.
-     */
+    /** Handles the received help code event. */
     receiveHelpCode(event) {
         var _a, _b;
         if (this.requestContext === null) {
             const { success, data } = event.detail;
             if (!success) {
-                const message = `Noibu help code is not available due to ${data}`;
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(message, false, SEVERITY.error);
+                const msg = `Noibu help code is not available due to ${data}`;
+                ClientConfig.getInstance().postInternalError({ msg }, false, SEVERITY.error);
             }
             return;
         }

package/dist/api/InputManager.js

@@ -0,0 +1,156 @@
+import { __awaiter } from 'tslib';
+import MetroplexSocket from './MetroplexSocket.js';
+import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
+import HelpCode from './HelpCode.js';
+import { Singleton } from '../monitors/BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
+import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+
+// maximum ids that a user can add to a pagevisit
+const MAX_CUSTOM_IDS_PER_PAGEVISIT = 10;
+const MAX_CUSTOM_ERRORS_PER_PAGEVISIT = 500;
+const TOO_MANY_IDS_ADDED_MSG = 'TOO_MANY_IDS_ADDED';
+const ID_NAME_ALREADY_ADDED_MSG = 'ID_NAME_ALREADY_ADDED';
+const NAME_TOO_LONG_MSG = 'NAME_TOO_LONG';
+const VALUE_TOO_LONG_MSG = 'VALUE_TOO_LONG';
+const INVALID_NAME_TYPE_MSG = 'INVALID_NAME_TYPE';
+const INVALID_VALUE_TYPE_MSG = 'INVALID_VALUE_TYPE';
+const NAME_HAS_NO_LENGTH_MSG = 'NAME_HAS_NO_LENGTH';
+const VALUE_HAS_NO_LENGTH_MSG = 'VALUE_HAS_NO_LENGTH';
+const SUCCESS_MSG = 'SUCCESS';
+const ERROR_HAS_NO_MSG_MSG = 'ERROR_HAS_NO_MSG';
+const ERROR_HAS_NO_STACK_MSG = 'ERROR_HAS_NO_STACK';
+const NULL_CUSTOM_ERR_MSG = 'NULL_CUSTOM_ERROR';
+const TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT_MSG = 'TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT';
+/** this class controls the input that customers can inject into
+ * our script via the NoibuJS SDK
+ */
+class InputManager extends Singleton {
+    constructor() {
+        super(...arguments);
+        this.customIDs = {};
+        this.customErrorsCount = 0;
+    }
+    /** exposes functions to the window of the browser for the clients
+     * to interact with on their end
+     */
+    exposeFunctions() {
+        return {
+            // adding all the functions and binding the current context
+            // so that we can use the exposed function as if they are running`
+            // in the noibujs script
+            requestHelpCode: this._requestHelpCode.bind(this),
+            addCustomAttribute: this._addCustomAttribute.bind(this),
+            addError: this._addCustomError.bind(this),
+            addJsSdkError: this._addErrorFromJSSdk.bind(this),
+        };
+    }
+    /** validates the custom error that was passed */
+    getErrorValidationError(customError) {
+        if (!customError) {
+            return NULL_CUSTOM_ERR_MSG;
+        }
+        if (!customError.message) {
+            return ERROR_HAS_NO_MSG_MSG;
+        }
+        if (!customError.stack) {
+            return ERROR_HAS_NO_STACK_MSG;
+        }
+        return SUCCESS_MSG;
+    }
+    /** Validates and sets the custom error to our internal trackers */
+    _validateAndSetCustomError(customError) {
+        // we cap the number of errors allowed to be sent
+        if (this.customErrorsCount >= MAX_CUSTOM_ERRORS_PER_PAGEVISIT) {
+            return TOO_MANY_ERRORS_RECEIVED_PER_PAGEVISIT_MSG;
+        }
+        // need to validate first before we start operating with the received
+        // data
+        const validationResult = this.getErrorValidationError(customError);
+        if (validationResult !== SUCCESS_MSG) {
+            return validationResult;
+        }
+        this.customErrorsCount += 1;
+        return SUCCESS_MSG;
+    }
+    /** adds an error from a JS Sdk to the session */
+    _addErrorFromJSSdk(customError, errorSource) {
+        const validationAndSettingResult = this._validateAndSetCustomError(customError);
+        if (validationAndSettingResult !== SUCCESS_MSG) {
+            return validationAndSettingResult;
+        }
+        saveErrorToPagevisit({ error: customError, type: `${errorSource}` });
+        return validationAndSettingResult;
+    }
+    /** adds a custom Error to the session */
+    _addCustomError(customError) {
+        const validationAndSettingResult = this._validateAndSetCustomError(customError);
+        if (validationAndSettingResult !== SUCCESS_MSG) {
+            return validationAndSettingResult;
+        }
+        // customError is validated at this point
+        saveErrorToPagevisit({ type: PageVisitErrorSource.CustomError, error: customError });
+        return validationAndSettingResult;
+    }
+    /**
+     * adds a custom id to the session
+     * todo wrong param types, should be unknown
+     */
+    _addCustomAttribute(name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // we return if we are over the limit of ids
+            if (Object.keys(this.customIDs).length >= MAX_CUSTOM_IDS_PER_PAGEVISIT) {
+                return TOO_MANY_IDS_ADDED_MSG;
+            }
+            // need to validate first before we start operating with the received
+            // data
+            const validationResult = this.getValidationError(name, value);
+            if (validationResult !== SUCCESS_MSG) {
+                return validationResult;
+            }
+            // we do not want to keep sending something that was already sent
+            if (name in this.customIDs) {
+                return ID_NAME_ALREADY_ADDED_MSG;
+            }
+            this.customIDs[name] = value;
+            yield MetroplexSocket.getInstance().sendMessage({
+                type: WebsocketMessageType.PageVisitMeta,
+                payload: {
+                    id_name: name,
+                    id_val: value,
+                },
+            });
+            return SUCCESS_MSG;
+        });
+    }
+    /** validation function for customer input */
+    getValidationError(name, value) {
+        // all ids need to be strings and less than 50 chars and more than 0 chars
+        if (typeof name !== 'string') {
+            return INVALID_NAME_TYPE_MSG;
+        }
+        if (typeof value !== 'string') {
+            return INVALID_VALUE_TYPE_MSG;
+        }
+        if (value.length > 50) {
+            return VALUE_TOO_LONG_MSG;
+        }
+        if (name.length > 50) {
+            return NAME_TOO_LONG_MSG;
+        }
+        if (value.length === 0) {
+            return VALUE_HAS_NO_LENGTH_MSG;
+        }
+        if (name.length === 0) {
+            return NAME_HAS_NO_LENGTH_MSG;
+        }
+        return SUCCESS_MSG;
+    }
+    /** Requests a help code from the HelpCode instance. */
+    _requestHelpCode() {
+        return HelpCode.getInstance().requestHelpCode();
+    }
+}
+
+export { InputManager as default };