@webex/contact-center 0.0.0-next.1

package/dist/services/core/constants.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WS_DISCONNECT_ALLOWED = exports.WELCOME_TIMEOUT = exports.TIMEOUT_REQ = exports.RTD_PING_EVENT = exports.PING_API_URL = exports.NOTIFS_RESOLVE_DELAY = exports.METHODS = exports.LOST_CONNECTION_RECOVERY_TIMEOUT = exports.KEEPALIVE_WORKER_INTERVAL = exports.CONNECTIVITY_CHECK_INTERVAL = exports.CLOSE_SOCKET_TIMEOUT_DURATION = exports.CLOSE_SOCKET_TIMEOUT = void 0;
+/**
+ * Interval in milliseconds for sending keepalive pings to the worker.
+ * @ignore
+ */
+const KEEPALIVE_WORKER_INTERVAL = exports.KEEPALIVE_WORKER_INTERVAL = 4000;
+
+/**
+ * Delay in milliseconds before resolving notification handlers.
+ * @ignore
+ */
+const NOTIFS_RESOLVE_DELAY = exports.NOTIFS_RESOLVE_DELAY = 1200;
+
+/**
+ * Timeout duration in milliseconds before forcefully closing a WebSocket connection.
+ * @ignore
+ */
+const CLOSE_SOCKET_TIMEOUT_DURATION = exports.CLOSE_SOCKET_TIMEOUT_DURATION = 16000;
+
+/**
+ * API endpoint used for connectivity or health checks.
+ * @ignore
+ */
+const PING_API_URL = exports.PING_API_URL = '/health';
+
+/**
+ * Timeout in milliseconds to wait for a welcome message after socket connection.
+ * @ignore
+ */
+const WELCOME_TIMEOUT = exports.WELCOME_TIMEOUT = 30000;
+
+/**
+ * Event name used for real-time device (RTD) ping status.
+ * @ignore
+ */
+const RTD_PING_EVENT = exports.RTD_PING_EVENT = 'rtd-online-status';
+
+/**
+ * Timeout in milliseconds for individual HTTP requests.
+ * @ignore
+ */
+const TIMEOUT_REQ = exports.TIMEOUT_REQ = 20000;
+
+/**
+ * Duration in milliseconds to wait before attempting lost connection recovery.
+ * @ignore
+ */
+const LOST_CONNECTION_RECOVERY_TIMEOUT = exports.LOST_CONNECTION_RECOVERY_TIMEOUT = 50000;
+
+/**
+ * Duration in milliseconds after which a WebSocket disconnect is considered allowed or expected.
+ * @ignore
+ */
+const WS_DISCONNECT_ALLOWED = exports.WS_DISCONNECT_ALLOWED = 8000;
+
+/**
+ * Interval in milliseconds to check for connectivity status.
+ * @ignore
+ */
+const CONNECTIVITY_CHECK_INTERVAL = exports.CONNECTIVITY_CHECK_INTERVAL = 5000;
+
+/**
+ * Timeout in milliseconds for cleanly closing the WebSocket.
+ * @ignore
+ */
+const CLOSE_SOCKET_TIMEOUT = exports.CLOSE_SOCKET_TIMEOUT = 16000;
+
+// Method names for core services
+const METHODS = exports.METHODS = {
+  // WebexRequest methods
+  REQUEST: 'request',
+  UPLOAD_LOGS: 'uploadLogs',
+  // Utils methods
+  GET_ERROR_DETAILS: 'getErrorDetails',
+  GET_COMMON_ERROR_DETAILS: 'getCommonErrorDetails',
+  CREATE_ERR_DETAILS_OBJECT: 'createErrDetailsObject',
+  // AqmReqs methods
+  REQ: 'req',
+  REQ_EMPTY: 'reqEmpty',
+  MAKE_API_REQUEST: 'makeAPIRequest',
+  CREATE_PROMISE: 'createPromise',
+  BIND_PRINT: 'bindPrint',
+  BIND_CHECK: 'bindCheck',
+  ON_MESSAGE: 'onMessage',
+  // WebSocketManager methods
+  INIT_WEB_SOCKET: 'initWebSocket',
+  CLOSE: 'close',
+  HANDLE_CONNECTION_LOST: 'handleConnectionLost',
+  REGISTER: 'register',
+  CONNECT: 'connect',
+  WEB_SOCKET_ON_CLOSE_HANDLER: 'webSocketOnCloseHandler',
+  // ConnectionService methods
+  SETUP_EVENT_LISTENERS: 'setupEventListeners',
+  DISPATCH_CONNECTION_EVENT: 'dispatchConnectionEvent',
+  CS_HANDLE_CONNECTION_LOST: 'handleConnectionLost',
+  CLEAR_TIMER_ON_RESTORE_FAILED: 'clearTimerOnRestoreFailed',
+  HANDLE_RESTORE_FAILED: 'handleRestoreFailed',
+  UPDATE_CONNECTION_DATA: 'updateConnectionData',
+  SET_CONNECTION_PROP: 'setConnectionProp',
+  ON_PING: 'onPing',
+  HANDLE_SOCKET_CLOSE: 'handleSocketClose',
+  ON_SOCKET_CLOSE: 'onSocketClose'
+};
+//# sourceMappingURL=constants.js.map

package/dist/services/core/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KEEPALIVE_WORKER_INTERVAL","exports","NOTIFS_RESOLVE_DELAY","CLOSE_SOCKET_TIMEOUT_DURATION","PING_API_URL","WELCOME_TIMEOUT","RTD_PING_EVENT","TIMEOUT_REQ","LOST_CONNECTION_RECOVERY_TIMEOUT","WS_DISCONNECT_ALLOWED","CONNECTIVITY_CHECK_INTERVAL","CLOSE_SOCKET_TIMEOUT","METHODS","REQUEST","UPLOAD_LOGS","GET_ERROR_DETAILS","GET_COMMON_ERROR_DETAILS","CREATE_ERR_DETAILS_OBJECT","REQ","REQ_EMPTY","MAKE_API_REQUEST","CREATE_PROMISE","BIND_PRINT","BIND_CHECK","ON_MESSAGE","INIT_WEB_SOCKET","CLOSE","HANDLE_CONNECTION_LOST","REGISTER","CONNECT","WEB_SOCKET_ON_CLOSE_HANDLER","SETUP_EVENT_LISTENERS","DISPATCH_CONNECTION_EVENT","CS_HANDLE_CONNECTION_LOST","CLEAR_TIMER_ON_RESTORE_FAILED","HANDLE_RESTORE_FAILED","UPDATE_CONNECTION_DATA","SET_CONNECTION_PROP","ON_PING","HANDLE_SOCKET_CLOSE","ON_SOCKET_CLOSE"],"sources":["constants.ts"],"sourcesContent":["/**\n * Interval in milliseconds for sending keepalive pings to the worker.\n * @ignore\n */\nexport const KEEPALIVE_WORKER_INTERVAL = 4000;\n\n/**\n * Delay in milliseconds before resolving notification handlers.\n * @ignore\n */\nexport const NOTIFS_RESOLVE_DELAY = 1200;\n\n/**\n * Timeout duration in milliseconds before forcefully closing a WebSocket connection.\n * @ignore\n */\nexport const CLOSE_SOCKET_TIMEOUT_DURATION = 16000;\n\n/**\n * API endpoint used for connectivity or health checks.\n * @ignore\n */\nexport const PING_API_URL = '/health';\n\n/**\n * Timeout in milliseconds to wait for a welcome message after socket connection.\n * @ignore\n */\nexport const WELCOME_TIMEOUT = 30000;\n\n/**\n * Event name used for real-time device (RTD) ping status.\n * @ignore\n */\nexport const RTD_PING_EVENT = 'rtd-online-status';\n\n/**\n * Timeout in milliseconds for individual HTTP requests.\n * @ignore\n */\nexport const TIMEOUT_REQ = 20000;\n\n/**\n * Duration in milliseconds to wait before attempting lost connection recovery.\n * @ignore\n */\nexport const LOST_CONNECTION_RECOVERY_TIMEOUT = 50000;\n\n/**\n * Duration in milliseconds after which a WebSocket disconnect is considered allowed or expected.\n * @ignore\n */\nexport const WS_DISCONNECT_ALLOWED = 8000;\n\n/**\n * Interval in milliseconds to check for connectivity status.\n * @ignore\n */\nexport const CONNECTIVITY_CHECK_INTERVAL = 5000;\n\n/**\n * Timeout in milliseconds for cleanly closing the WebSocket.\n * @ignore\n */\nexport const CLOSE_SOCKET_TIMEOUT = 16000;\n\n// Method names for core services\nexport const METHODS = {\n  // WebexRequest methods\n  REQUEST: 'request',\n  UPLOAD_LOGS: 'uploadLogs',\n\n  // Utils methods\n  GET_ERROR_DETAILS: 'getErrorDetails',\n  GET_COMMON_ERROR_DETAILS: 'getCommonErrorDetails',\n  CREATE_ERR_DETAILS_OBJECT: 'createErrDetailsObject',\n\n  // AqmReqs methods\n  REQ: 'req',\n  REQ_EMPTY: 'reqEmpty',\n  MAKE_API_REQUEST: 'makeAPIRequest',\n  CREATE_PROMISE: 'createPromise',\n  BIND_PRINT: 'bindPrint',\n  BIND_CHECK: 'bindCheck',\n  ON_MESSAGE: 'onMessage',\n\n  // WebSocketManager methods\n  INIT_WEB_SOCKET: 'initWebSocket',\n  CLOSE: 'close',\n  HANDLE_CONNECTION_LOST: 'handleConnectionLost',\n  REGISTER: 'register',\n  CONNECT: 'connect',\n  WEB_SOCKET_ON_CLOSE_HANDLER: 'webSocketOnCloseHandler',\n\n  // ConnectionService methods\n  SETUP_EVENT_LISTENERS: 'setupEventListeners',\n  DISPATCH_CONNECTION_EVENT: 'dispatchConnectionEvent',\n  CS_HANDLE_CONNECTION_LOST: 'handleConnectionLost',\n  CLEAR_TIMER_ON_RESTORE_FAILED: 'clearTimerOnRestoreFailed',\n  HANDLE_RESTORE_FAILED: 'handleRestoreFailed',\n  UPDATE_CONNECTION_DATA: 'updateConnectionData',\n  SET_CONNECTION_PROP: 'setConnectionProp',\n  ON_PING: 'onPing',\n  HANDLE_SOCKET_CLOSE: 'handleSocketClose',\n  ON_SOCKET_CLOSE: 'onSocketClose',\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACO,MAAMA,yBAAyB,GAAAC,OAAA,CAAAD,yBAAA,GAAG,IAAI;;AAE7C;AACA;AACA;AACA;AACO,MAAME,oBAAoB,GAAAD,OAAA,CAAAC,oBAAA,GAAG,IAAI;;AAExC;AACA;AACA;AACA;AACO,MAAMC,6BAA6B,GAAAF,OAAA,CAAAE,6BAAA,GAAG,KAAK;;AAElD;AACA;AACA;AACA;AACO,MAAMC,YAAY,GAAAH,OAAA,CAAAG,YAAA,GAAG,SAAS;;AAErC;AACA;AACA;AACA;AACO,MAAMC,eAAe,GAAAJ,OAAA,CAAAI,eAAA,GAAG,KAAK;;AAEpC;AACA;AACA;AACA;AACO,MAAMC,cAAc,GAAAL,OAAA,CAAAK,cAAA,GAAG,mBAAmB;;AAEjD;AACA;AACA;AACA;AACO,MAAMC,WAAW,GAAAN,OAAA,CAAAM,WAAA,GAAG,KAAK;;AAEhC;AACA;AACA;AACA;AACO,MAAMC,gCAAgC,GAAAP,OAAA,CAAAO,gCAAA,GAAG,KAAK;;AAErD;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,GAAAR,OAAA,CAAAQ,qBAAA,GAAG,IAAI;;AAEzC;AACA;AACA;AACA;AACO,MAAMC,2BAA2B,GAAAT,OAAA,CAAAS,2BAAA,GAAG,IAAI;;AAE/C;AACA;AACA;AACA;AACO,MAAMC,oBAAoB,GAAAV,OAAA,CAAAU,oBAAA,GAAG,KAAK;;AAEzC;AACO,MAAMC,OAAO,GAAAX,OAAA,CAAAW,OAAA,GAAG;EACrB;EACAC,OAAO,EAAE,SAAS;EAClBC,WAAW,EAAE,YAAY;EAEzB;EACAC,iBAAiB,EAAE,iBAAiB;EACpCC,wBAAwB,EAAE,uBAAuB;EACjDC,yBAAyB,EAAE,wBAAwB;EAEnD;EACAC,GAAG,EAAE,KAAK;EACVC,SAAS,EAAE,UAAU;EACrBC,gBAAgB,EAAE,gBAAgB;EAClCC,cAAc,EAAE,eAAe;EAC/BC,UAAU,EAAE,WAAW;EACvBC,UAAU,EAAE,WAAW;EACvBC,UAAU,EAAE,WAAW;EAEvB;EACAC,eAAe,EAAE,eAAe;EAChCC,KAAK,EAAE,OAAO;EACdC,sBAAsB,EAAE,sBAAsB;EAC9CC,QAAQ,EAAE,UAAU;EACpBC,OAAO,EAAE,SAAS;EAClBC,2BAA2B,EAAE,yBAAyB;EAEtD;EACAC,qBAAqB,EAAE,qBAAqB;EAC5CC,yBAAyB,EAAE,yBAAyB;EACpDC,yBAAyB,EAAE,sBAAsB;EACjDC,6BAA6B,EAAE,2BAA2B;EAC1DC,qBAAqB,EAAE,qBAAqB;EAC5CC,sBAAsB,EAAE,sBAAsB;EAC9CC,mBAAmB,EAAE,mBAAmB;EACxCC,OAAO,EAAE,QAAQ;EACjBC,mBAAmB,EAAE,mBAAmB;EACxCC,eAAe,EAAE;AACnB,CAAC"}

package/dist/services/core/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/dist/services/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import {HTTP_METHODS, RequestBody, WebexRequestPayload} from '../../types';\nimport * as Err from './Err';\nimport {Msg} from './GlobalTypes';\n\nexport type Pending = {\n  check: (msg: Msg) => boolean;\n  handle: (msg: Msg) => void;\n  alternateBind?: string;\n};\n\nexport type BindType = string | string[] | {[key: string]: BindType};\ninterface Bind {\n  type: BindType;\n  data?: any;\n}\n\nexport type Timeout = number | 'disabled';\n\nexport type Req<TRes, TErr> = {\n  url: string;\n  host?: string;\n  method?: HTTP_METHODS;\n  err?:\n    | ((errObj: WebexRequestPayload) => Err.Details<'Service.reqs.generic.failure'>)\n    | Err.IdsMessage\n    | ((e: WebexRequestPayload) => Err.Message | Err.Details<Err.IdsDetails>);\n  notifSuccess: {bind: Bind; msg: TRes};\n  notifFail?:\n    | {\n        bind: Bind;\n        errMsg: TErr;\n        err: (e: TErr) => Err.Details<Err.IdsDetails>;\n      }\n    | {\n        bind: Bind;\n        errId: Err.IdsDetails;\n      };\n  data?: RequestBody;\n  headers?: Record<string, string>;\n  timeout?: Timeout;\n  notifCancel?: {bind: Bind; msg: TRes};\n};\n\nexport type Conf<TRes, TErr, TReq> = (p: TReq) => Req<TRes, TErr>;\nexport type ConfEmpty<TRes, TErr> = () => Req<TRes, TErr>;\nexport type Res<TRes, TReq> = (p: TReq, cbRes?: CbRes<TRes>) => Promise<TRes>;\nexport type ResEmpty<TRes> = (cbRes?: CbRes<TRes>) => Promise<TRes>;\nexport type CbRes<TRes> = (res: any) => void | TRes;\n"],"mappings":""}

package/dist/services/core/websocket/WebSocketManager.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebSocketManager = void 0;
+var _events = _interopRequireDefault(require("events"));
+var _types = require("../../../types");
+var _constants = require("../../constants");
+var _types2 = require("../../config/types");
+var _loggerProxy = _interopRequireDefault(require("../../../logger-proxy"));
+var _keepalive = _interopRequireDefault(require("./keepalive.worker"));
+var _constants2 = require("../constants");
+var _constants3 = require("../../../constants");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * WebSocketManager handles the WebSocket connection for Contact Center operations.
+ * It manages the connection lifecycle, including registration, reconnection, and message handling.
+ * It also utilizes a Web Worker to manage keepalive messages and socket closure.
+ * @ignore
+ */
+class WebSocketManager extends _events.default {
+  url = null;
+  welcomePromiseResolve = null;
+  constructor(options) {
+    super();
+    const {
+      webex
+    } = options;
+    this.webex = webex;
+    this.shouldReconnect = true;
+    this.websocket = {};
+    this.isSocketClosed = false;
+    this.isWelcomeReceived = false;
+    this.forceCloseWebSocketOnTimeout = false;
+    this.isConnectionLost = false;
+    const workerScriptBlob = new Blob([_keepalive.default], {
+      type: 'application/javascript'
+    });
+    this.keepaliveWorker = new Worker(URL.createObjectURL(workerScriptBlob));
+  }
+  async initWebSocket(options) {
+    const connectionConfig = options.body;
+    await this.register(connectionConfig);
+    return new Promise((resolve, reject) => {
+      this.welcomePromiseResolve = resolve;
+      this.connect().catch(error => {
+        _loggerProxy.default.error(`[WebSocketStatus] | Error in connecting Websocket ${error}`, {
+          module: _constants3.WEB_SOCKET_MANAGER_FILE,
+          method: _constants2.METHODS.INIT_WEB_SOCKET
+        });
+        reject(error);
+      });
+    });
+  }
+  close(shouldReconnect, reason = 'Unknown') {
+    if (!this.isSocketClosed && this.shouldReconnect) {
+      this.shouldReconnect = shouldReconnect;
+      this.websocket.close();
+      this.keepaliveWorker.postMessage({
+        type: 'terminate'
+      });
+      _loggerProxy.default.log(`[WebSocketStatus] | event=webSocketClose | WebSocket connection closed manually REASON: ${reason}`, {
+        module: _constants3.WEB_SOCKET_MANAGER_FILE,
+        method: _constants2.METHODS.CLOSE
+      });
+    }
+  }
+  handleConnectionLost(event) {
+    this.isConnectionLost = event.isConnectionLost;
+  }
+  async register(connectionConfig) {
+    try {
+      const subscribeResponse = await this.webex.request({
+        service: _constants.WCC_API_GATEWAY,
+        resource: _constants.SUBSCRIBE_API,
+        method: _types.HTTP_METHODS.POST,
+        body: connectionConfig
+      });
+      this.url = subscribeResponse.body.webSocketUrl;
+    } catch (e) {
+      _loggerProxy.default.error(`Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`, {
+        module: _constants3.WEB_SOCKET_MANAGER_FILE,
+        method: _constants2.METHODS.REGISTER
+      });
+    }
+  }
+  async connect() {
+    if (!this.url) {
+      return undefined;
+    }
+    _loggerProxy.default.log(`[WebSocketStatus] | event=webSocketConnecting | Connecting to WebSocket: ${this.url}`, {
+      module: _constants3.WEB_SOCKET_MANAGER_FILE,
+      method: _constants2.METHODS.CONNECT
+    });
+    this.websocket = new WebSocket(this.url);
+    return new Promise((resolve, reject) => {
+      this.websocket.onopen = () => {
+        this.isSocketClosed = false;
+        this.shouldReconnect = true;
+        this.websocket.send(JSON.stringify({
+          keepalive: 'true'
+        }));
+        this.keepaliveWorker.onmessage = keepAliveEvent => {
+          if (keepAliveEvent?.data?.type === 'keepalive') {
+            this.websocket.send(JSON.stringify({
+              keepalive: 'true'
+            }));
+          }
+          if (keepAliveEvent?.data?.type === 'closeSocket' && this.isConnectionLost) {
+            this.forceCloseWebSocketOnTimeout = true;
+            this.close(true, 'WebSocket did not auto close within 16 secs');
+            _loggerProxy.default.error('[webSocketTimeout] | event=webSocketTimeout | WebSocket connection closed forcefully', {
+              module: _constants3.WEB_SOCKET_MANAGER_FILE,
+              method: _constants2.METHODS.CONNECT
+            });
+          }
+        };
+        this.keepaliveWorker.postMessage({
+          type: 'start',
+          intervalDuration: _constants2.KEEPALIVE_WORKER_INTERVAL,
+          // Keepalive interval
+          isSocketClosed: this.isSocketClosed,
+          closeSocketTimeout: _constants2.CLOSE_SOCKET_TIMEOUT // Close socket timeout
+        });
+      };
+
+      this.websocket.onerror = event => {
+        _loggerProxy.default.error(`[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed ${event}`, {
+          module: _constants3.WEB_SOCKET_MANAGER_FILE,
+          method: _constants2.METHODS.CONNECT
+        });
+        reject();
+      };
+      this.websocket.onclose = async event => {
+        this.webSocketOnCloseHandler(event);
+      };
+      this.websocket.onmessage = e => {
+        this.emit('message', e.data);
+        const eventData = JSON.parse(e.data);
+        if (eventData.type === _types2.CC_EVENTS.WELCOME) {
+          this.isWelcomeReceived = true;
+          if (this.welcomePromiseResolve) {
+            this.welcomePromiseResolve(eventData.data);
+            this.welcomePromiseResolve = null;
+          }
+        }
+        if (eventData.type === 'AGENT_MULTI_LOGIN') {
+          this.close(false, 'multiLogin');
+          _loggerProxy.default.error('[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin', {
+            module: _constants3.WEB_SOCKET_MANAGER_FILE,
+            method: _constants2.METHODS.CONNECT
+          });
+        }
+      };
+    });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async webSocketOnCloseHandler(event) {
+    this.isSocketClosed = true;
+    this.keepaliveWorker.postMessage({
+      type: 'terminate'
+    });
+    if (this.shouldReconnect) {
+      this.emit('socketClose');
+      let issueReason;
+      if (this.forceCloseWebSocketOnTimeout) {
+        issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';
+      } else {
+        const onlineStatus = navigator.onLine;
+        _loggerProxy.default.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`, {
+          module: _constants3.WEB_SOCKET_MANAGER_FILE,
+          method: _constants2.METHODS.WEB_SOCKET_ON_CLOSE_HANDLER
+        });
+        issueReason = !onlineStatus ? 'network issue' : 'missing keepalive from either desktop or notif service';
+      }
+      _loggerProxy.default.error(`[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: ${issueReason}`, {
+        module: _constants3.WEB_SOCKET_MANAGER_FILE,
+        method: _constants2.METHODS.WEB_SOCKET_ON_CLOSE_HANDLER
+      });
+      this.forceCloseWebSocketOnTimeout = false;
+    }
+  }
+}
+exports.WebSocketManager = WebSocketManager;
+//# sourceMappingURL=WebSocketManager.js.map

package/dist/services/core/websocket/WebSocketManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_events","_interopRequireDefault","require","_types","_constants","_types2","_loggerProxy","_keepalive","_constants2","_constants3","obj","__esModule","default","WebSocketManager","EventEmitter","url","welcomePromiseResolve","constructor","options","webex","shouldReconnect","websocket","isSocketClosed","isWelcomeReceived","forceCloseWebSocketOnTimeout","isConnectionLost","workerScriptBlob","Blob","workerScript","type","keepaliveWorker","Worker","URL","createObjectURL","initWebSocket","connectionConfig","body","register","Promise","resolve","reject","connect","catch","error","LoggerProxy","module","WEB_SOCKET_MANAGER_FILE","method","METHODS","INIT_WEB_SOCKET","close","reason","postMessage","log","CLOSE","handleConnectionLost","event","subscribeResponse","request","service","WCC_API_GATEWAY","resource","SUBSCRIBE_API","HTTP_METHODS","POST","webSocketUrl","e","REGISTER","undefined","CONNECT","WebSocket","onopen","send","JSON","stringify","keepalive","onmessage","keepAliveEvent","data","intervalDuration","KEEPALIVE_WORKER_INTERVAL","closeSocketTimeout","CLOSE_SOCKET_TIMEOUT","onerror","onclose","webSocketOnCloseHandler","emit","eventData","parse","CC_EVENTS","WELCOME","issueReason","onlineStatus","navigator","onLine","info","WEB_SOCKET_ON_CLOSE_HANDLER","exports"],"sources":["WebSocketManager.ts"],"sourcesContent":["import EventEmitter from 'events';\nimport {WebexSDK, SubscribeRequest, HTTP_METHODS} from '../../../types';\nimport {SUBSCRIBE_API, WCC_API_GATEWAY} from '../../constants';\nimport {ConnectionLostDetails} from './types';\nimport {CC_EVENTS, SubscribeResponse, WelcomeResponse} from '../../config/types';\nimport LoggerProxy from '../../../logger-proxy';\nimport workerScript from './keepalive.worker';\nimport {KEEPALIVE_WORKER_INTERVAL, CLOSE_SOCKET_TIMEOUT, METHODS} from '../constants';\nimport {WEB_SOCKET_MANAGER_FILE} from '../../../constants';\n\n/**\n * WebSocketManager handles the WebSocket connection for Contact Center operations.\n * It manages the connection lifecycle, including registration, reconnection, and message handling.\n * It also utilizes a Web Worker to manage keepalive messages and socket closure.\n * @ignore\n */\nexport class WebSocketManager extends EventEmitter {\n  private websocket: WebSocket;\n  shouldReconnect: boolean;\n  isSocketClosed: boolean;\n  private isWelcomeReceived: boolean;\n  private url: string | null = null;\n  private forceCloseWebSocketOnTimeout: boolean;\n  private isConnectionLost: boolean;\n  private webex: WebexSDK;\n  private welcomePromiseResolve:\n    | ((value: WelcomeResponse | PromiseLike<WelcomeResponse>) => void)\n    | null = null;\n\n  private keepaliveWorker: Worker;\n\n  constructor(options: {webex: WebexSDK}) {\n    super();\n    const {webex} = options;\n    this.webex = webex;\n    this.shouldReconnect = true;\n    this.websocket = {} as WebSocket;\n    this.isSocketClosed = false;\n    this.isWelcomeReceived = false;\n    this.forceCloseWebSocketOnTimeout = false;\n    this.isConnectionLost = false;\n\n    const workerScriptBlob = new Blob([workerScript], {type: 'application/javascript'});\n    this.keepaliveWorker = new Worker(URL.createObjectURL(workerScriptBlob));\n  }\n\n  async initWebSocket(options: {body: SubscribeRequest}): Promise<WelcomeResponse> {\n    const connectionConfig = options.body;\n    await this.register(connectionConfig);\n\n    return new Promise((resolve, reject) => {\n      this.welcomePromiseResolve = resolve;\n      this.connect().catch((error) => {\n        LoggerProxy.error(`[WebSocketStatus] | Error in connecting Websocket ${error}`, {\n          module: WEB_SOCKET_MANAGER_FILE,\n          method: METHODS.INIT_WEB_SOCKET,\n        });\n        reject(error);\n      });\n    });\n  }\n\n  close(shouldReconnect: boolean, reason = 'Unknown') {\n    if (!this.isSocketClosed && this.shouldReconnect) {\n      this.shouldReconnect = shouldReconnect;\n      this.websocket.close();\n      this.keepaliveWorker.postMessage({type: 'terminate'});\n      LoggerProxy.log(\n        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed manually REASON: ${reason}`,\n        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CLOSE}\n      );\n    }\n  }\n\n  handleConnectionLost(event: ConnectionLostDetails) {\n    this.isConnectionLost = event.isConnectionLost;\n  }\n\n  private async register(connectionConfig: SubscribeRequest) {\n    try {\n      const subscribeResponse: SubscribeResponse = await this.webex.request({\n        service: WCC_API_GATEWAY,\n        resource: SUBSCRIBE_API,\n        method: HTTP_METHODS.POST,\n        body: connectionConfig,\n      });\n      this.url = subscribeResponse.body.webSocketUrl;\n    } catch (e) {\n      LoggerProxy.error(\n        `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`,\n        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.REGISTER}\n      );\n    }\n  }\n\n  private async connect() {\n    if (!this.url) {\n      return undefined;\n    }\n    LoggerProxy.log(\n      `[WebSocketStatus] | event=webSocketConnecting | Connecting to WebSocket: ${this.url}`,\n      {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}\n    );\n    this.websocket = new WebSocket(this.url);\n\n    return new Promise((resolve, reject) => {\n      this.websocket.onopen = () => {\n        this.isSocketClosed = false;\n        this.shouldReconnect = true;\n\n        this.websocket.send(JSON.stringify({keepalive: 'true'}));\n        this.keepaliveWorker.onmessage = (keepAliveEvent: {data: any}) => {\n          if (keepAliveEvent?.data?.type === 'keepalive') {\n            this.websocket.send(JSON.stringify({keepalive: 'true'}));\n          }\n\n          if (keepAliveEvent?.data?.type === 'closeSocket' && this.isConnectionLost) {\n            this.forceCloseWebSocketOnTimeout = true;\n            this.close(true, 'WebSocket did not auto close within 16 secs');\n            LoggerProxy.error(\n              '[webSocketTimeout] | event=webSocketTimeout | WebSocket connection closed forcefully',\n              {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}\n            );\n          }\n        };\n\n        this.keepaliveWorker.postMessage({\n          type: 'start',\n          intervalDuration: KEEPALIVE_WORKER_INTERVAL, // Keepalive interval\n          isSocketClosed: this.isSocketClosed,\n          closeSocketTimeout: CLOSE_SOCKET_TIMEOUT, // Close socket timeout\n        });\n      };\n\n      this.websocket.onerror = (event: any) => {\n        LoggerProxy.error(\n          `[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed ${event}`,\n          {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}\n        );\n        reject();\n      };\n\n      this.websocket.onclose = async (event: any) => {\n        this.webSocketOnCloseHandler(event);\n      };\n\n      this.websocket.onmessage = (e: MessageEvent) => {\n        this.emit('message', e.data);\n        const eventData = JSON.parse(e.data);\n\n        if (eventData.type === CC_EVENTS.WELCOME) {\n          this.isWelcomeReceived = true;\n          if (this.welcomePromiseResolve) {\n            this.welcomePromiseResolve(eventData.data as WelcomeResponse);\n            this.welcomePromiseResolve = null;\n          }\n        }\n\n        if (eventData.type === 'AGENT_MULTI_LOGIN') {\n          this.close(false, 'multiLogin');\n          LoggerProxy.error(\n            '[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin',\n            {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.CONNECT}\n          );\n        }\n      };\n    });\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  private async webSocketOnCloseHandler(event: any) {\n    this.isSocketClosed = true;\n    this.keepaliveWorker.postMessage({type: 'terminate'});\n    if (this.shouldReconnect) {\n      this.emit('socketClose');\n      let issueReason;\n      if (this.forceCloseWebSocketOnTimeout) {\n        issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';\n      } else {\n        const onlineStatus = navigator.onLine;\n        LoggerProxy.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`, {\n          module: WEB_SOCKET_MANAGER_FILE,\n          method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER,\n        });\n        issueReason = !onlineStatus\n          ? 'network issue'\n          : 'missing keepalive from either desktop or notif service';\n      }\n      LoggerProxy.error(\n        `[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: ${issueReason}`,\n        {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER}\n      );\n      this.forceCloseWebSocketOnTimeout = false;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/services/core/websocket/connection-service.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConnectionService = void 0;
+var _events = require("events");
+var _loggerProxy = _interopRequireDefault(require("../../../logger-proxy"));
+var _constants = require("../constants");
+var _constants2 = require("../../../constants");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class ConnectionService extends _events.EventEmitter {
+  connectionProp = {
+    lostConnectionRecoveryTimeout: _constants.LOST_CONNECTION_RECOVERY_TIMEOUT
+  };
+  wsDisconnectAllowed = _constants.WS_DISCONNECT_ALLOWED;
+  constructor(options) {
+    super();
+    this.webSocketManager = options.webSocketManager;
+    this.subscribeRequest = options.subscribeRequest;
+    this.isConnectionLost = false;
+    this.isRestoreFailed = false;
+    this.isSocketReconnected = false;
+    this.isKeepAlive = false;
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    this.webSocketManager.on('message', this.onPing.bind(this));
+    this.webSocketManager.on('socketClose', this.onSocketClose.bind(this));
+  }
+  dispatchConnectionEvent(socketReconnected = false) {
+    const event = {
+      isConnectionLost: this.isConnectionLost,
+      isRestoreFailed: this.isRestoreFailed,
+      isSocketReconnected: !this.webSocketManager.isSocketClosed && (socketReconnected || this.isSocketReconnected),
+      isKeepAlive: this.isKeepAlive
+    };
+    this.webSocketManager.handleConnectionLost(event);
+    _loggerProxy.default.info(`Dispatching connection event`, {
+      module: _constants2.CONNECTION_SERVICE_FILE,
+      method: _constants.METHODS.DISPATCH_CONNECTION_EVENT
+    });
+    this.emit('connectionLost', event);
+  }
+  handleConnectionLost = () => {
+    this.isConnectionLost = true;
+    this.dispatchConnectionEvent();
+  };
+  clearTimerOnRestoreFailed = async () => {
+    if (this.reconnectInterval) {
+      clearInterval(this.reconnectInterval);
+    }
+  };
+  handleRestoreFailed = async () => {
+    this.isRestoreFailed = true;
+    this.webSocketManager.shouldReconnect = false;
+    this.dispatchConnectionEvent();
+    await this.clearTimerOnRestoreFailed();
+  };
+  updateConnectionData = () => {
+    this.isRestoreFailed = false;
+    this.isConnectionLost = false;
+    this.isSocketReconnected = false;
+  };
+  setConnectionProp(prop) {
+    this.connectionProp = prop;
+  }
+  onPing = event => {
+    const parsedEvent = JSON.parse(event);
+    if (this.reconnectingTimer) {
+      clearTimeout(this.reconnectingTimer);
+    }
+    if (this.restoreTimer) {
+      clearTimeout(this.restoreTimer);
+    }
+    this.isKeepAlive = parsedEvent.keepalive === 'true';
+    if ((this.isConnectionLost && !this.isRestoreFailed || this.isKeepAlive) && !this.isSocketReconnected) {
+      this.updateConnectionData();
+      this.dispatchConnectionEvent();
+    } else if (this.isSocketReconnected && this.isKeepAlive) {
+      this.updateConnectionData();
+      this.dispatchConnectionEvent(true);
+    }
+    this.reconnectingTimer = setTimeout(this.handleConnectionLost, this.wsDisconnectAllowed);
+    this.restoreTimer = setTimeout(this.handleRestoreFailed, this.connectionProp && this.connectionProp.lostConnectionRecoveryTimeout);
+  };
+  handleSocketClose = async () => {
+    _loggerProxy.default.info(`event=socketConnectionRetry | Trying to reconnect to websocket`, {
+      module: _constants2.CONNECTION_SERVICE_FILE,
+      method: _constants.METHODS.HANDLE_SOCKET_CLOSE
+    });
+    const onlineStatus = navigator.onLine;
+    if (onlineStatus) {
+      await this.webSocketManager.initWebSocket({
+        body: this.subscribeRequest
+      });
+      await this.clearTimerOnRestoreFailed();
+      this.isSocketReconnected = true;
+    } else {
+      throw new Error('event=socketConnectionRetry | browser network not available');
+    }
+  };
+  onSocketClose = () => {
+    this.clearTimerOnRestoreFailed();
+    this.reconnectInterval = setInterval(async () => {
+      await this.handleSocketClose();
+    }, _constants.CONNECTIVITY_CHECK_INTERVAL);
+  };
+}
+exports.ConnectionService = ConnectionService;
+//# sourceMappingURL=connection-service.js.map

package/dist/services/core/websocket/connection-service.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_events","require","_loggerProxy","_interopRequireDefault","_constants","_constants2","obj","__esModule","default","ConnectionService","EventEmitter","connectionProp","lostConnectionRecoveryTimeout","LOST_CONNECTION_RECOVERY_TIMEOUT","wsDisconnectAllowed","WS_DISCONNECT_ALLOWED","constructor","options","webSocketManager","subscribeRequest","isConnectionLost","isRestoreFailed","isSocketReconnected","isKeepAlive","setupEventListeners","on","onPing","bind","onSocketClose","dispatchConnectionEvent","socketReconnected","event","isSocketClosed","handleConnectionLost","LoggerProxy","info","module","CONNECTION_SERVICE_FILE","method","METHODS","DISPATCH_CONNECTION_EVENT","emit","clearTimerOnRestoreFailed","reconnectInterval","clearInterval","handleRestoreFailed","shouldReconnect","updateConnectionData","setConnectionProp","prop","parsedEvent","JSON","parse","reconnectingTimer","clearTimeout","restoreTimer","keepalive","setTimeout","handleSocketClose","HANDLE_SOCKET_CLOSE","onlineStatus","navigator","onLine","initWebSocket","body","Error","setInterval","CONNECTIVITY_CHECK_INTERVAL","exports"],"sources":["connection-service.ts"],"sourcesContent":["import {EventEmitter} from 'events';\nimport {WebSocketManager} from './WebSocketManager';\nimport LoggerProxy from '../../../logger-proxy';\nimport {ConnectionServiceOptions, ConnectionLostDetails, ConnectionProp} from './types';\nimport {\n  LOST_CONNECTION_RECOVERY_TIMEOUT,\n  WS_DISCONNECT_ALLOWED,\n  CONNECTIVITY_CHECK_INTERVAL,\n  METHODS,\n} from '../constants';\nimport {CONNECTION_SERVICE_FILE} from '../../../constants';\nimport {SubscribeRequest} from '../../../types';\n\nexport class ConnectionService extends EventEmitter {\n  private connectionProp: ConnectionProp = {\n    lostConnectionRecoveryTimeout: LOST_CONNECTION_RECOVERY_TIMEOUT,\n  };\n\n  private wsDisconnectAllowed = WS_DISCONNECT_ALLOWED;\n  private reconnectingTimer: ReturnType<typeof setTimeout>;\n  private restoreTimer: ReturnType<typeof setTimeout>;\n  private isConnectionLost: boolean;\n  private isRestoreFailed: boolean;\n  private isSocketReconnected: boolean;\n  private isKeepAlive: boolean;\n  private reconnectInterval: ReturnType<typeof setInterval>;\n  private webSocketManager: WebSocketManager;\n  private subscribeRequest: SubscribeRequest;\n\n  constructor(options: ConnectionServiceOptions) {\n    super();\n    this.webSocketManager = options.webSocketManager;\n    this.subscribeRequest = options.subscribeRequest;\n\n    this.isConnectionLost = false;\n    this.isRestoreFailed = false;\n    this.isSocketReconnected = false;\n    this.isKeepAlive = false;\n\n    this.setupEventListeners();\n  }\n\n  private setupEventListeners() {\n    this.webSocketManager.on('message', this.onPing.bind(this));\n    this.webSocketManager.on('socketClose', this.onSocketClose.bind(this));\n  }\n\n  private dispatchConnectionEvent(socketReconnected = false): void {\n    const event: ConnectionLostDetails = {\n      isConnectionLost: this.isConnectionLost,\n      isRestoreFailed: this.isRestoreFailed,\n      isSocketReconnected:\n        !this.webSocketManager.isSocketClosed && (socketReconnected || this.isSocketReconnected),\n      isKeepAlive: this.isKeepAlive,\n    };\n    this.webSocketManager.handleConnectionLost(event);\n    LoggerProxy.info(`Dispatching connection event`, {\n      module: CONNECTION_SERVICE_FILE,\n      method: METHODS.DISPATCH_CONNECTION_EVENT,\n    });\n    this.emit('connectionLost', event);\n  }\n\n  private handleConnectionLost = (): void => {\n    this.isConnectionLost = true;\n    this.dispatchConnectionEvent();\n  };\n\n  private clearTimerOnRestoreFailed = async () => {\n    if (this.reconnectInterval) {\n      clearInterval(this.reconnectInterval);\n    }\n  };\n\n  private handleRestoreFailed = async () => {\n    this.isRestoreFailed = true;\n    this.webSocketManager.shouldReconnect = false;\n    this.dispatchConnectionEvent();\n    await this.clearTimerOnRestoreFailed();\n  };\n\n  private updateConnectionData = (): void => {\n    this.isRestoreFailed = false;\n    this.isConnectionLost = false;\n    this.isSocketReconnected = false;\n  };\n\n  public setConnectionProp(prop: ConnectionProp): void {\n    this.connectionProp = prop;\n  }\n\n  private onPing = (event: any): void => {\n    const parsedEvent = JSON.parse(event);\n    if (this.reconnectingTimer) {\n      clearTimeout(this.reconnectingTimer);\n    }\n    if (this.restoreTimer) {\n      clearTimeout(this.restoreTimer);\n    }\n    this.isKeepAlive = parsedEvent.keepalive === 'true';\n\n    if (\n      ((this.isConnectionLost && !this.isRestoreFailed) || this.isKeepAlive) &&\n      !this.isSocketReconnected\n    ) {\n      this.updateConnectionData();\n      this.dispatchConnectionEvent();\n    } else if (this.isSocketReconnected && this.isKeepAlive) {\n      this.updateConnectionData();\n      this.dispatchConnectionEvent(true);\n    }\n\n    this.reconnectingTimer = setTimeout(this.handleConnectionLost, this.wsDisconnectAllowed);\n    this.restoreTimer = setTimeout(\n      this.handleRestoreFailed,\n      this.connectionProp && this.connectionProp.lostConnectionRecoveryTimeout\n    );\n  };\n\n  private handleSocketClose = async (): Promise<void> => {\n    LoggerProxy.info(`event=socketConnectionRetry | Trying to reconnect to websocket`, {\n      module: CONNECTION_SERVICE_FILE,\n      method: METHODS.HANDLE_SOCKET_CLOSE,\n    });\n    const onlineStatus = navigator.onLine;\n    if (onlineStatus) {\n      await this.webSocketManager.initWebSocket({body: this.subscribeRequest});\n      await this.clearTimerOnRestoreFailed();\n      this.isSocketReconnected = true;\n    } else {\n      throw new Error('event=socketConnectionRetry | browser network not available');\n    }\n  };\n\n  private onSocketClose = (): void => {\n    this.clearTimerOnRestoreFailed();\n\n    this.reconnectInterval = setInterval(async () => {\n      await this.handleSocketClose();\n    }, CONNECTIVITY_CHECK_INTERVAL);\n  };\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,YAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,UAAA,GAAAH,OAAA;AAMA,IAAAI,WAAA,GAAAJ,OAAA;AAA2D,SAAAE,uBAAAG,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAGpD,MAAMG,iBAAiB,SAASC,oBAAY,CAAC;EAC1CC,cAAc,GAAmB;IACvCC,6BAA6B,EAAEC;EACjC,CAAC;EAEOC,mBAAmB,GAAGC,gCAAqB;EAWnDC,WAAWA,CAACC,OAAiC,EAAE;IAC7C,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,gBAAgB,GAAGD,OAAO,CAACC,gBAAgB;IAChD,IAAI,CAACC,gBAAgB,GAAGF,OAAO,CAACE,gBAAgB;IAEhD,IAAI,CAACC,gBAAgB,GAAG,KAAK;IAC7B,IAAI,CAACC,eAAe,GAAG,KAAK;IAC5B,IAAI,CAACC,mBAAmB,GAAG,KAAK;IAChC,IAAI,CAACC,WAAW,GAAG,KAAK;IAExB,IAAI,CAACC,mBAAmB,CAAC,CAAC;EAC5B;EAEQA,mBAAmBA,CAAA,EAAG;IAC5B,IAAI,CAACN,gBAAgB,CAACO,EAAE,CAAC,SAAS,EAAE,IAAI,CAACC,MAAM,CAACC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,IAAI,CAACT,gBAAgB,CAACO,EAAE,CAAC,aAAa,EAAE,IAAI,CAACG,aAAa,CAACD,IAAI,CAAC,IAAI,CAAC,CAAC;EACxE;EAEQE,uBAAuBA,CAACC,iBAAiB,GAAG,KAAK,EAAQ;IAC/D,MAAMC,KAA4B,GAAG;MACnCX,gBAAgB,EAAE,IAAI,CAACA,gBAAgB;MACvCC,eAAe,EAAE,IAAI,CAACA,eAAe;MACrCC,mBAAmB,EACjB,CAAC,IAAI,CAACJ,gBAAgB,CAACc,cAAc,KAAKF,iBAAiB,IAAI,IAAI,CAACR,mBAAmB,CAAC;MAC1FC,WAAW,EAAE,IAAI,CAACA;IACpB,CAAC;IACD,IAAI,CAACL,gBAAgB,CAACe,oBAAoB,CAACF,KAAK,CAAC;IACjDG,oBAAW,CAACC,IAAI,CAAE,8BAA6B,EAAE;MAC/CC,MAAM,EAAEC,mCAAuB;MAC/BC,MAAM,EAAEC,kBAAO,CAACC;IAClB,CAAC,CAAC;IACF,IAAI,CAACC,IAAI,CAAC,gBAAgB,EAAEV,KAAK,CAAC;EACpC;EAEQE,oBAAoB,GAAGA,CAAA,KAAY;IACzC,IAAI,CAACb,gBAAgB,GAAG,IAAI;IAC5B,IAAI,CAACS,uBAAuB,CAAC,CAAC;EAChC,CAAC;EAEOa,yBAAyB,GAAG,MAAAA,CAAA,KAAY;IAC9C,IAAI,IAAI,CAACC,iBAAiB,EAAE;MAC1BC,aAAa,CAAC,IAAI,CAACD,iBAAiB,CAAC;IACvC;EACF,CAAC;EAEOE,mBAAmB,GAAG,MAAAA,CAAA,KAAY;IACxC,IAAI,CAACxB,eAAe,GAAG,IAAI;IAC3B,IAAI,CAACH,gBAAgB,CAAC4B,eAAe,GAAG,KAAK;IAC7C,IAAI,CAACjB,uBAAuB,CAAC,CAAC;IAC9B,MAAM,IAAI,CAACa,yBAAyB,CAAC,CAAC;EACxC,CAAC;EAEOK,oBAAoB,GAAGA,CAAA,KAAY;IACzC,IAAI,CAAC1B,eAAe,GAAG,KAAK;IAC5B,IAAI,CAACD,gBAAgB,GAAG,KAAK;IAC7B,IAAI,CAACE,mBAAmB,GAAG,KAAK;EAClC,CAAC;EAEM0B,iBAAiBA,CAACC,IAAoB,EAAQ;IACnD,IAAI,CAACtC,cAAc,GAAGsC,IAAI;EAC5B;EAEQvB,MAAM,GAAIK,KAAU,IAAW;IACrC,MAAMmB,WAAW,GAAGC,IAAI,CAACC,KAAK,CAACrB,KAAK,CAAC;IACrC,IAAI,IAAI,CAACsB,iBAAiB,EAAE;MAC1BC,YAAY,CAAC,IAAI,CAACD,iBAAiB,CAAC;IACtC;IACA,IAAI,IAAI,CAACE,YAAY,EAAE;MACrBD,YAAY,CAAC,IAAI,CAACC,YAAY,CAAC;IACjC;IACA,IAAI,CAAChC,WAAW,GAAG2B,WAAW,CAACM,SAAS,KAAK,MAAM;IAEnD,IACE,CAAE,IAAI,CAACpC,gBAAgB,IAAI,CAAC,IAAI,CAACC,eAAe,IAAK,IAAI,CAACE,WAAW,KACrE,CAAC,IAAI,CAACD,mBAAmB,EACzB;MACA,IAAI,CAACyB,oBAAoB,CAAC,CAAC;MAC3B,IAAI,CAAClB,uBAAuB,CAAC,CAAC;IAChC,CAAC,MAAM,IAAI,IAAI,CAACP,mBAAmB,IAAI,IAAI,CAACC,WAAW,EAAE;MACvD,IAAI,CAACwB,oBAAoB,CAAC,CAAC;MAC3B,IAAI,CAAClB,uBAAuB,CAAC,IAAI,CAAC;IACpC;IAEA,IAAI,CAACwB,iBAAiB,GAAGI,UAAU,CAAC,IAAI,CAACxB,oBAAoB,EAAE,IAAI,CAACnB,mBAAmB,CAAC;IACxF,IAAI,CAACyC,YAAY,GAAGE,UAAU,CAC5B,IAAI,CAACZ,mBAAmB,EACxB,IAAI,CAAClC,cAAc,IAAI,IAAI,CAACA,cAAc,CAACC,6BAC7C,CAAC;EACH,CAAC;EAEO8C,iBAAiB,GAAG,MAAAA,CAAA,KAA2B;IACrDxB,oBAAW,CAACC,IAAI,CAAE,gEAA+D,EAAE;MACjFC,MAAM,EAAEC,mCAAuB;MAC/BC,MAAM,EAAEC,kBAAO,CAACoB;IAClB,CAAC,CAAC;IACF,MAAMC,YAAY,GAAGC,SAAS,CAACC,MAAM;IACrC,IAAIF,YAAY,EAAE;MAChB,MAAM,IAAI,CAAC1C,gBAAgB,CAAC6C,aAAa,CAAC;QAACC,IAAI,EAAE,IAAI,CAAC7C;MAAgB,CAAC,CAAC;MACxE,MAAM,IAAI,CAACuB,yBAAyB,CAAC,CAAC;MACtC,IAAI,CAACpB,mBAAmB,GAAG,IAAI;IACjC,CAAC,MAAM;MACL,MAAM,IAAI2C,KAAK,CAAC,6DAA6D,CAAC;IAChF;EACF,CAAC;EAEOrC,aAAa,GAAGA,CAAA,KAAY;IAClC,IAAI,CAACc,yBAAyB,CAAC,CAAC;IAEhC,IAAI,CAACC,iBAAiB,GAAGuB,WAAW,CAAC,YAAY;MAC/C,MAAM,IAAI,CAACR,iBAAiB,CAAC,CAAC;IAChC,CAAC,EAAES,sCAA2B,CAAC;EACjC,CAAC;AACH;AAACC,OAAA,CAAA3D,iBAAA,GAAAA,iBAAA"}

package/dist/services/core/websocket/keepalive.worker.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// TODO: Try to find alternative to using Blob and script here
+const workerScript = `
+console.log("*** Keepalive Worker Thread ***");
+let intervalId, intervalDuration, timeOutId, isSocketClosed, closeSocketTimeout;
+let initialised = false;
+let initiateWebSocketClosure = false;
+
+const resetOfflineHandler = function () {
+  if (timeOutId) {
+    initialised = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+const checkOnlineStatus = function () {
+  const onlineStatus = navigator.onLine;
+  console.log(
+    \`[WebSocketStatus] event=checkOnlineStatus | online status=\`,
+    onlineStatus
+  );
+  return onlineStatus;
+};
+
+// Checks network status and if it's offline then force closes WebSocket
+const checkNetworkStatus = function () {
+  const onlineStatus = checkOnlineStatus();
+  postMessage({ type: "keepalive", onlineStatus });
+  if (!onlineStatus && !initialised) {
+    initialised = true;
+    // Sets a timeout of 16s, checks if socket didn't close then it closes forcefully
+    timeOutId = setTimeout(() => {
+      if (!isSocketClosed) {
+        initiateWebSocketClosure = true;
+        postMessage({ type: "closeSocket" });
+      }
+    }, closeSocketTimeout);
+  }
+
+  if (onlineStatus && initialised) {
+    initialised = false;
+  }
+
+  if (initiateWebSocketClosure) {
+    initiateWebSocketClosure = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+addEventListener("message", (event) => {
+  if (event.data?.type === "start") {
+    intervalDuration = event.data?.intervalDuration || 4000;
+    closeSocketTimeout = event.data?.closeSocketTimeout || 5000;
+    console.log("event=Websocket startWorker | keepalive Worker started");
+    intervalId = setInterval(
+      (checkIfSocketClosed) => {
+        checkNetworkStatus();
+        isSocketClosed = checkIfSocketClosed;
+      },
+      intervalDuration,
+      event.data?.isSocketClosed
+    );
+
+    resetOfflineHandler();
+  }
+
+  if (event.data?.type === "terminate" && intervalId) {
+    console.log("event=Websocket terminateWorker | keepalive Worker stopped");
+    clearInterval(intervalId);
+    intervalId = null;
+    resetOfflineHandler();
+  }
+});
+
+// Listen for online and offline events
+self.addEventListener('online', () => {
+  console.log('Network status: online');
+  checkNetworkStatus();
+});
+
+self.addEventListener('offline', () => {
+  console.log('Network status: offline');
+  checkNetworkStatus();
+});
+`;
+var _default = exports.default = workerScript;
+//# sourceMappingURL=keepalive.worker.js.map

package/dist/services/core/websocket/keepalive.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["workerScript","_default","exports","default"],"sources":["keepalive.worker.js"],"sourcesContent":["// TODO: Try to find alternative to using Blob and script here\nconst workerScript = `\nconsole.log(\"*** Keepalive Worker Thread ***\");\nlet intervalId, intervalDuration, timeOutId, isSocketClosed, closeSocketTimeout;\nlet initialised = false;\nlet initiateWebSocketClosure = false;\n\nconst resetOfflineHandler = function () {\n  if (timeOutId) {\n    initialised = false;\n    clearTimeout(timeOutId);\n    timeOutId = null;\n  }\n};\n\nconst checkOnlineStatus = function () {\n  const onlineStatus = navigator.onLine;\n  console.log(\n    \\`[WebSocketStatus] event=checkOnlineStatus | online status=\\`,\n    onlineStatus\n  );\n  return onlineStatus;\n};\n\n// Checks network status and if it's offline then force closes WebSocket\nconst checkNetworkStatus = function () {\n  const onlineStatus = checkOnlineStatus();\n  postMessage({ type: \"keepalive\", onlineStatus });\n  if (!onlineStatus && !initialised) {\n    initialised = true;\n    // Sets a timeout of 16s, checks if socket didn't close then it closes forcefully\n    timeOutId = setTimeout(() => {\n      if (!isSocketClosed) {\n        initiateWebSocketClosure = true;\n        postMessage({ type: \"closeSocket\" });\n      }\n    }, closeSocketTimeout);\n  }\n\n  if (onlineStatus && initialised) {\n    initialised = false;\n  }\n\n  if (initiateWebSocketClosure) {\n    initiateWebSocketClosure = false;\n    clearTimeout(timeOutId);\n    timeOutId = null;\n  }\n};\n\naddEventListener(\"message\", (event) => {\n  if (event.data?.type === \"start\") {\n    intervalDuration = event.data?.intervalDuration || 4000;\n    closeSocketTimeout = event.data?.closeSocketTimeout || 5000;\n    console.log(\"event=Websocket startWorker | keepalive Worker started\");\n    intervalId = setInterval(\n      (checkIfSocketClosed) => {\n        checkNetworkStatus();\n        isSocketClosed = checkIfSocketClosed;\n      },\n      intervalDuration,\n      event.data?.isSocketClosed\n    );\n\n    resetOfflineHandler();\n  }\n\n  if (event.data?.type === \"terminate\" && intervalId) {\n    console.log(\"event=Websocket terminateWorker | keepalive Worker stopped\");\n    clearInterval(intervalId);\n    intervalId = null;\n    resetOfflineHandler();\n  }\n});\n\n// Listen for online and offline events\nself.addEventListener('online', () => {\n  console.log('Network status: online');\n  checkNetworkStatus();\n});\n\nself.addEventListener('offline', () => {\n  console.log('Network status: offline');\n  checkNetworkStatus();\n});\n`;\n\nexport default workerScript;\n"],"mappings":";;;;;;AAAA;AACA,MAAMA,YAAY,GAAI;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEaH,YAAY"}

package/dist/services/core/websocket/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/dist/services/core/websocket/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import {SubscribeRequest} from '../../../types';\nimport {WebSocketManager} from './WebSocketManager';\n\n/**\n * Options for initializing a connection service.\n * @typedef ConnectionServiceOptions\n * @property {WebSocketManager} webSocketManager - The WebSocket manager instance.\n * @property {SubscribeRequest} subscribeRequest - The subscribe request payload.\n * @ignore\n */\nexport type ConnectionServiceOptions = {\n  webSocketManager: WebSocketManager;\n  subscribeRequest: SubscribeRequest;\n};\n\n/**\n * Details about the state of a lost connection and recovery attempts.\n * @typedef ConnectionLostDetails\n * @property {boolean} isConnectionLost - Indicates if the connection is currently lost.\n * @property {boolean} isRestoreFailed - Indicates if restoring the connection has failed.\n * @property {boolean} isSocketReconnected - Indicates if the socket has been reconnected.\n * @property {boolean} isKeepAlive - Indicates if the keep-alive mechanism is active.\n * @ignore\n */\nexport type ConnectionLostDetails = {\n  isConnectionLost: boolean;\n  isRestoreFailed: boolean;\n  isSocketReconnected: boolean;\n  isKeepAlive: boolean;\n};\n\n/**\n * Properties for connection configuration.\n * @typedef ConnectionProp\n * @property {number} lostConnectionRecoveryTimeout - Timeout in milliseconds for lost connection recovery.\n * @ignore\n */\nexport type ConnectionProp = {\n  lostConnectionRecoveryTimeout: number;\n};\n"],"mappings":""}