@monterosa/sdk-enmasse-kit 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/index.cjs

@@ -0,0 +1,2180 @@
+'use strict';
+
+var sdkUtil = require('@monterosa/sdk-util');
+var sdkStorageKit = require('@monterosa/sdk-storage-kit');
+var sdkLauncherKit = require('@monterosa/sdk-launcher-kit');
+
+const ARG_OVERRIDE_METHODS = 'enmasse_override_methods';
+const ARG_DEBUG = 'enmasse_debug';
+const ARG_CONFIG = 'enmasse_config';
+
+const SSCP_KLASS_AUTH = 'auth';
+const SSCP_KLASS_AUTHR = 'authr';
+const SSCP_KLASS_AUTHOK = 'authok';
+const SSCP_KLASS_PING = 'ping';
+const SSCP_KLASS_SUB = 'sub';
+const SSCP_KLASS_UNSUB = 'unsub';
+const SSCP_KLASS_EOC = 'eoc';
+const SSCP_KLASS_LOGIN = 'login';
+const SSCP_KLASS_LOGIN_OK = 'login_ok';
+const SSCP_KLASS_LOGIN_FAIL = 'login_fail';
+const SSCP_KLASS_LOGOUT = 'logout';
+const SSCP_KLASS_COUNTER = 'counter';
+
+const getSettingFor = (name) => {
+  if (sdkUtil.checkAvailability()) {
+    const value = sdkUtil.getItem(name);
+
+    if (value !== null) {
+      return value;
+    }
+  }
+
+  // Guarding the use of the window object in environments where it might not be
+  // available, such as during server - side rendering in a framework like Next.js
+  if (typeof window === 'undefined') {
+    return null;
+  }
+
+  const { searchParams } = new URL(window.location.href);
+
+  if (searchParams.has(name)) {
+    return searchParams.get(name);
+  }
+
+  return false;
+};
+
+const getSettingForMethods = () => {
+  const value = getSettingFor(ARG_OVERRIDE_METHODS);
+
+  if (typeof value === 'string') {
+    return value.split(',');
+  }
+
+  return undefined;
+};
+
+const ENMASSE_OVERRIDE_METHODS = getSettingForMethods();
+const ENMASSE_DEBUG = getSettingFor(ARG_DEBUG);
+const ENMASSE_CONFIG = getSettingFor(ARG_CONFIG);
+
+var version = "2.0.0-rc.4";
+
+/* eslint no-bitwise: "off" */
+
+const TYPE_PROTOCOL = 1; // 0000 0000 0001
+const TYPE_MANAGER = 2; // 0000 0000 0010
+const TYPE_TRANSPORT = 4; // 0000 0000 0100
+const TYPE_DRIVER = 8; // 0000 0000 1000
+const TYPE_QUEUE = 16; // 0000 0001 0000
+const TYPE_TIME = 32; // 0000 0010 0000
+const TYPE_MANAGER_EXTRA = 64; // 0000 0100 0000
+const TYPE_DRIVER_EXTRA = 128; // 0000 1000 0000
+const TYPE_SERVICE = 256; // 0001 0000 0000
+
+const LEVELS = {
+  brief: TYPE_PROTOCOL,
+  full: TYPE_PROTOCOL | TYPE_MANAGER | TYPE_TRANSPORT | TYPE_DRIVER,
+  exhaustive:
+    TYPE_PROTOCOL |
+    TYPE_MANAGER |
+    TYPE_MANAGER_EXTRA |
+    TYPE_TRANSPORT |
+    TYPE_DRIVER |
+    TYPE_DRIVER_EXTRA |
+    TYPE_QUEUE |
+    TYPE_TIME |
+    TYPE_SERVICE,
+};
+
+// eslint-disable-next-line
+let log = () => {};
+
+if (ENMASSE_DEBUG) {
+  log = (...args) => {
+    if (typeof console === 'undefined' || !console.log) {
+      return;
+    }
+
+    // parse arguments
+    // var args = Array.prototype.slice.call(arguments);
+
+    // the first argument is the debug type
+    const [type] = args;
+
+    // the rest of arguments are arbitrary data
+    const rest = args.slice(1);
+
+    // const time = ['getMinutes', 'getSeconds']
+    //   .map((f) => new Date()[f]())
+    //   .map((v) => (v < 10 ? '0' : '') + v)
+    //   .join(':');
+
+    // add current time
+    // rest.unshift(time);
+
+    // do not log if mask doesn't contain current type
+    if ((LEVELS[ENMASSE_DEBUG] & type) === 0) {
+      return;
+    }
+
+    console.log(...rest);
+  };
+}
+
+class Queue {
+  constructor(config = {}) {
+    // the main storage for messages
+    this.queue = [];
+
+    // stash of the queue
+    this.stashed = [];
+
+    this.running = false;
+
+    this.runner = typeof config.runner === 'function' ? config.runner : null;
+
+    // list of channels we subscribed to
+    this.subscriptions = [];
+  }
+
+  push(message, force = false) {
+    log(TYPE_QUEUE, 'Queue::push', message, force);
+
+    const { klass, channel } = message;
+
+    if (!force) {
+      switch (klass) {
+        case SSCP_KLASS_LOGIN:
+        case SSCP_KLASS_LOGOUT:
+        case SSCP_KLASS_AUTHR:
+          break;
+        case SSCP_KLASS_SUB:
+          if (this.subscriptions.indexOf(channel) === -1) {
+            this.subscriptions.push(channel);
+          } else {
+            return;
+          }
+          break;
+        case SSCP_KLASS_UNSUB: {
+          const index = this.subscriptions.indexOf(channel);
+
+          if (index !== -1) {
+            this.subscriptions.splice(index, 1);
+          } else {
+            return;
+          }
+          break;
+        }
+        default:
+          if (this.subscriptions.indexOf(channel) === -1) {
+            return;
+          }
+          break;
+      }
+    }
+
+    this.queue.push(message);
+  }
+
+  getSubscriptions() {
+    return this.subscriptions;
+  }
+
+  run() {
+    log(
+      TYPE_QUEUE,
+      'Queue::run',
+      `running=${this.running}, head=${this.queue[0]}`,
+    );
+
+    // abort if whether
+    // 1. runner function is not set
+    // 2. OR queue is already running
+    // 3. OR there is no messages in the queue
+    if (this.runner === null || this.running || !this.queue[0]) {
+      return;
+    }
+
+    this.running = true;
+
+    this.runner(this.queue.shift());
+  }
+
+  success() {
+    log(TYPE_QUEUE, 'Queue::success');
+
+    this.running = false;
+
+    this.run();
+  }
+
+  failure() {
+    log(TYPE_QUEUE, 'Queue::failure');
+
+    this.running = false;
+  }
+
+  stash() {
+    log(TYPE_QUEUE, 'Queue::stash');
+
+    let item;
+
+    // eslint-disable-next-line
+    while (undefined !== (item = this.queue.shift())) {
+      this.stashed.push(item);
+    }
+  }
+
+  unstash() {
+    log(TYPE_QUEUE, 'Queue::unstash');
+
+    let item;
+
+    // eslint-disable-next-line
+    while (undefined !== (item = this.stashed.shift())) {
+      this.queue.push(item);
+    }
+  }
+}
+
+// Returns current local timestamp
+const local = () => new Date() / 1000;
+
+// Server time default to local time
+let serverTime = local();
+
+// Time when the server time was received on the client
+let clientTimeAtSync = local();
+
+const setTime = (newTime) => {
+  log(TYPE_TIME, 'Time::setTime', newTime);
+
+  serverTime = newTime;
+  // offset = local() - time;
+  clientTimeAtSync = local();
+};
+
+const now = () => {
+  const elapsedTime = local() - clientTimeAtSync;
+
+  return Math.round(serverTime + elapsedTime);
+};
+
+class Transport extends sdkUtil.Emitter {
+  // generic events
+  static ON_READY = 'ready';
+  static ON_MESSAGE = 'message';
+
+  // connection state events
+  static ON_CONNECTED = 'connected';
+  static ON_CONNECT_FAILED = 'connect_failed';
+  static ON_CONNECT_LOST = 'connect_lost';
+  static ON_DISCONNECTED = 'disconnected';
+
+  // states
+  static STATE_CONNECTED = 'connected';
+  static STATE_CONNECTING = 'connecting';
+  static STATE_DISCONNECTED = 'disconnected';
+  static STATE_DISCONNECTING = 'disconnecting';
+
+  constructor() {
+    super();
+
+    this.state = this.STATE_DISCONNECTED;
+
+    this.trigger = this.emit;
+    this.bind = this.on;
+    this.unbind = this.off;
+  }
+}
+
+/* eslint class-methods-use-this: "off" */
+
+class Driver extends sdkUtil.Emitter {
+  static ON_READY = 'ready';
+  static ON_MESSAGE = 'message';
+  static ON_CONNECTED = 'connected';
+  static ON_DISCONNECTED = 'disconnected';
+
+  constructor() {
+    super();
+
+    this.connected = false;
+
+    this.trigger = this.emit;
+    this.bind = this.on;
+    this.unbind = this.off;
+  }
+
+  connect() {}
+
+  disconnect() {}
+
+  // Arguments:
+  //
+  // data = null
+  // success = () => {}
+  // failure = () => {}
+  send() {}
+
+  init() {
+    this.trigger(Driver.ON_READY);
+  }
+}
+
+const globals$1 = sdkUtil.getGlobal();
+
+class XHRDriver extends Driver {
+  constructor(config = {}) {
+    super();
+
+    this.config = config;
+    this.requests = {};
+    this.requestIdx = 0;
+  }
+
+  // CORS request wrapper
+  _request(url, success = () => {}, failure = () => {}, abort = () => {}) {
+    this.requestIdx += 1;
+
+    log(
+      TYPE_DRIVER_EXTRA,
+      `XHRDriver::request url=${url}, idx=${this.requestIdx}`,
+    );
+
+    const self = this;
+    let xhr = new XMLHttpRequest();
+    const method = 'POST';
+
+    if (typeof XDomainRequest !== 'undefined') {
+      xhr = new XDomainRequest();
+      xhr.open(method, url);
+    } else if ('withCredentials' in xhr) {
+      xhr.open(method, url, true);
+      xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
+    } else {
+      return null;
+    }
+
+    xhr._idx = this.requestIdx;
+
+    xhr.onload = function onLoad() {
+      log(
+        TYPE_DRIVER_EXTRA,
+        `XHRDriver::request::onload idx=${xhr._idx}, response=${this.responseText}`,
+      );
+
+      if (this.responseText.length > 0) {
+        success(self._parseResponse(this.responseText));
+      } else {
+        failure(this.responseText);
+      }
+    };
+
+    xhr.onerror = function onError() {
+      log(
+        TYPE_DRIVER_EXTRA,
+        `XHRDriver::request::onerror idx=${xhr._idx}, response=${this.responseText}`,
+      );
+
+      failure(this.responseText);
+    };
+
+    // XHR doesn't trigger onabort event in IE < 10
+    // attaching custom abort handler and execute
+    // it manually on each abort() call
+    xhr._onabort = () => {
+      log(
+        TYPE_DRIVER_EXTRA,
+        `XHRDriver::request::onabort idx=${xhr._idx}`,
+      );
+
+      abort();
+    };
+
+    return xhr;
+  }
+
+  _parseResponse(response) {
+    const data = {};
+    const chunks = response.split('&');
+
+    for (let i = 0, l = chunks.length; i < l; i++) {
+      const [key, value] = chunks[i].split('=');
+
+      const normalisedValue = decodeURIComponent(value.replace('\0', ''));
+
+      if (key in data) {
+        if (data[key].constructor !== Array) {
+          data[key] = [data[key]];
+        }
+        data[key].push(normalisedValue);
+      } else {
+        data[key] = normalisedValue;
+      }
+    }
+
+    return data;
+  }
+
+  _removeRequest(idx) {
+    log(TYPE_DRIVER_EXTRA, 'XHRDriver::removeRequest', idx);
+
+    if (Object.prototype.hasOwnProperty.call(this.requests, idx)) {
+      delete this.requests[idx];
+    }
+  }
+
+  connect() {
+    log(TYPE_DRIVER, 'XHRDriver::connect');
+
+    if (this.connected) {
+      log(
+        TYPE_DRIVER,
+        'XHRDriver::connect already been connected!',
+      );
+
+      return;
+    }
+
+    this.connected = true;
+
+    this.trigger(XHRDriver.ON_CONNECTED);
+  }
+
+  disconnect() {
+    log(TYPE_DRIVER, 'XHRDriver::disconnect');
+
+    if (this.connected) {
+      // abort all requests
+      for (const idx in this.requests) {
+        if (
+          Object.prototype.hasOwnProperty.call(this.requests, idx) &&
+          this.requests[idx].abort
+        ) {
+          this.requests[idx].abort();
+
+          if (this.requests[idx]._onabort) {
+            this.requests[idx]._onabort();
+          }
+
+          this._removeRequest(idx);
+        }
+      }
+
+      this.connected = false;
+    }
+
+    this.trigger(XHRDriver.ON_DISCONNECTED);
+  }
+
+  send(url, data, success = () => {}, failure = () => {}) {
+    log(TYPE_DRIVER, 'XHRDriver::send', data);
+
+    let xhr;
+    let retry = 1;
+
+    const send = () => {
+      // eslint-disable-next-line
+      xhr = this._request(url, onSuccess, onFailure, onAbort);
+
+      this.requests[xhr._idx] = xhr;
+
+      // fixes aborting requests in IE
+      setTimeout(() => {
+        xhr.send(data);
+      }, 0);
+    };
+
+    const onSuccess = (response) => {
+      log(TYPE_DRIVER, 'XHRDriver::success', data);
+      this._removeRequest(xhr._idx);
+      success(response);
+    };
+
+    const onFailure = (response) => {
+      log(TYPE_DRIVER, 'XHRDriver::failure, retry: ', retry);
+      this._removeRequest(xhr._idx);
+      if (retry <= this.config.request_retries) {
+        setTimeout(() => {
+          send();
+          retry++;
+        }, this.config.request_retry_delay * 1000);
+      } else {
+        failure(response);
+      }
+    };
+
+    const onAbort = () => {
+      log(TYPE_DRIVER, 'XHRDriver::abort', data);
+      this._removeRequest(xhr._idx);
+      failure();
+    };
+
+    send();
+  }
+
+  static hasSupport() {
+    return (
+      'XDomainRequest' in globals$1 || 'withCredentials' in new XMLHttpRequest()
+    );
+  }
+}
+
+/* eslint class-methods-use-this: "off" */
+
+const globals = sdkUtil.getGlobal();
+
+class WebSocketDriver extends Driver {
+  constructor() {
+    super();
+
+    this.websocket = null;
+    this.closeTimeout = null;
+  }
+
+  _onMessage(e) {
+    log(TYPE_DRIVER, 'WebSocketDriver::onMessage', e.data);
+    this.trigger(WebSocketDriver.ON_MESSAGE, e.data);
+  }
+
+  _onOpen() {
+    log(TYPE_DRIVER, 'WebSocketDriver::onOpen');
+    this.connected = true;
+    this.trigger(WebSocketDriver.ON_CONNECTED);
+  }
+
+  _onClose() {
+    log(TYPE_DRIVER, 'WebSocketDriver::onClose');
+    this._disconnect();
+  }
+
+  _onError() {
+    log(TYPE_DRIVER, 'WebSocketDriver::onError');
+  }
+
+  _disconnect() {
+    log(TYPE_DRIVER, 'WebSocketDriver::disconnect');
+
+    this.connected = false;
+
+    // reset handlers if websocket was created
+    if (this.websocket !== null) {
+      this.websocket.onmessage = () => {};
+      this.websocket.onopen = () => {};
+      this.websocket.onclose = () => {};
+      this.websocket.onerror = () => {};
+      this.websocket = null;
+    }
+
+    clearTimeout(this.closeTimeout);
+
+    this.trigger(WebSocketDriver.ON_DISCONNECTED);
+  }
+
+  connect(host, port, secure) {
+    if (this.connected) {
+      return;
+    }
+
+    log(TYPE_DRIVER, 'WebSocketDriver::connect', host, port);
+
+    const url = `${secure ? 'wss' : 'ws'}://${host}:${port}/ws`;
+
+    this.websocket = new WebSocket(url);
+    this.websocket.onmessage = this._onMessage.bind(this);
+    this.websocket.onopen = this._onOpen.bind(this);
+    this.websocket.onclose = this._onClose.bind(this);
+    this.websocket.onerror = this._onError.bind(this);
+  }
+
+  disconnect() {
+    log(TYPE_DRIVER, 'WebSocketDriver::disconnect');
+
+    if (this.connected) {
+      // ON_DISCONNECTED will be triggered at onClose event
+      this.websocket.close();
+
+      // websocket does not fire onclose if network connection is lost
+      // set timeout to force fire ON_DISCONNECTED event
+      this.closeTimeout = setTimeout(this._disconnect.bind(this), 750);
+    } else {
+      // disconnect instantly if websocket wasn't connected or still connecting
+      this._disconnect();
+    }
+  }
+
+  send(data, success = () => {}) {
+    log(TYPE_DRIVER, 'WebSocketDriver::send', data);
+    this.websocket.send(data);
+    success();
+  }
+
+  static hasSupport() {
+    return 'WebSocket' in globals;
+  }
+}
+
+const COMMAND_CONNECT = 'connect';
+const COMMAND_PASS = 'pass';
+const COMMAND_POLL = 'poll';
+
+class ProxyTransport extends Transport {
+  constructor(config = {}) {
+    log(TYPE_TRANSPORT, 'ProxyTransport::constructor', config);
+
+    super(config);
+
+    this.driver = config.driver || null;
+    this.host = config.host || null;
+    this.port = config.port || null;
+    this.secure = config.secure || false;
+
+    /*
+     * Proxy properties
+     * host and port should be always preserved on connect and reconnect
+     * drop proxyIp, childId and clientId on reconnect and disconnect
+     */
+
+    this.proxyIp = null;
+    this.childId = null;
+    this.clientId = null;
+    this.sessionId = null;
+
+    this.driver.bind(Driver.ON_READY, this._handleDriverReady.bind(this));
+    this.driver.bind(
+      Driver.ON_CONNECTED,
+      this._handleDriverConnected.bind(this),
+    );
+    this.driver.bind(
+      Driver.ON_DISCONNECTED,
+      this._handleDriverDisconnected.bind(this),
+    );
+  }
+
+  _url() {
+    return (
+      `${this.secure ? 'https' : 'http'}://` +
+      `${this.proxyIp ? this.proxyIp : this.host}:` +
+      `${this.port}/` +
+      `${this.childId !== null ? `${this.childId}/` : ''}` +
+      `?_r=${new Date().getTime()}`
+    );
+  }
+
+  _request(params = '', success = () => {}, failure = () => {}) {
+    const self = this;
+
+    const onSuccess = (response) => {
+      // fire ON_MESSAGE event unless sscp message is empty
+      if (response.sscp.constructor === String) {
+        response.sscp = [response.sscp];
+      }
+
+      for (let i = 0, l = response.sscp.length; i < l; i++) {
+        if (response.sscp[i] !== '') {
+          self.trigger(ProxyTransport.ON_MESSAGE, response.sscp[i]);
+        }
+      }
+
+      success(response);
+    };
+
+    const onFailure = () => {
+      switch (self.state) {
+        case ProxyTransport.STATE_CONNECTED:
+          self.state = ProxyTransport.STATE_DISCONNECTING;
+          self.trigger(ProxyTransport.ON_CONNECT_FAILED);
+          break;
+        case ProxyTransport.STATE_CONNECTING:
+          self.state = ProxyTransport.STATE_DISCONNECTING;
+          self.trigger(ProxyTransport.ON_CONNECT_FAILED);
+          break;
+        case ProxyTransport.STATE_DISCONNECTING:
+          self.state = ProxyTransport.STATE_DISCONNECTED;
+          self.trigger(ProxyTransport.ON_DISCONNECTED);
+          break;
+      }
+
+      failure();
+    };
+
+    this.driver.send(this._url(), params, onSuccess, onFailure);
+  }
+
+  _poll() {
+    const params =
+      `command=${COMMAND_POLL}` +
+      `&clientid=${this.clientId}` +
+      `&sid=${this.sessionId}`;
+
+    this._request(params, this._poll.bind(this));
+  }
+
+  _connect() {
+    const self = this;
+
+    const onSuccess = (response) => {
+      self.proxyIp = response.proxy;
+      self.clientId = parseInt(response.clientid, 10);
+      self.childId = parseInt(response.childid, 10);
+      self.sessionId = response.sid;
+
+      self.state = ProxyTransport.STATE_CONNECTED;
+
+      self.trigger(ProxyTransport.ON_CONNECTED);
+
+      self._poll();
+    };
+
+    const onFailure = () => {
+      self.state = ProxyTransport.STATE_DISCONNECTED;
+      self.trigger(ProxyTransport.ON_CONNECT_FAILED);
+    };
+
+    const params = `command=${COMMAND_CONNECT}`;
+
+    this._request(params, onSuccess, onFailure);
+  }
+
+  _handleDriverReady() {
+    this.trigger(ProxyTransport.ON_READY);
+  }
+
+  _handleDriverConnected() {
+    this._connect();
+  }
+
+  _handleDriverDisconnected() {
+    log(
+      TYPE_TRANSPORT,
+      'ProxyTransport::handleDriverDisconnected',
+    );
+
+    const { state } = this;
+
+    this.state = ProxyTransport.STATE_DISCONNECTED;
+
+    switch (state) {
+      case ProxyTransport.STATE_CONNECTED:
+        this.trigger(ProxyTransport.ON_CONNECT_LOST);
+        break;
+      case ProxyTransport.STATE_CONNECTING:
+        this.trigger(ProxyTransport.ON_CONNECT_FAILED);
+        break;
+      case ProxyTransport.STATE_DISCONNECTING:
+        this.trigger(ProxyTransport.ON_DISCONNECTED);
+        break;
+    }
+  }
+
+  send(sscp, success = () => {}, failure = () => {}) {
+    log(TYPE_TRANSPORT, 'ProxyTransport::send', sscp);
+
+    const params =
+      `command=${COMMAND_PASS}` +
+      `&clientid=${this.clientId}` +
+      `&sscp=${sscp}` +
+      `&sid=${this.sessionId}`;
+
+    this._request(params, success, failure);
+  }
+
+  connect() {
+    log(
+      TYPE_TRANSPORT,
+      'ProxyTransport::connect',
+      this.host,
+      this.port,
+    );
+
+    this.state = ProxyTransport.STATE_CONNECTING;
+    this.driver.connect();
+  }
+
+  disconnect() {
+    log(TYPE_TRANSPORT, 'ProxyTransport::disconnect');
+
+    // drop proxy settings
+    this.proxyIp = null;
+    this.childId = null;
+    this.sessionId = null;
+    this.state = ProxyTransport.STATE_DISCONNECTING;
+
+    this.driver.disconnect();
+  }
+
+  init() {
+    log(TYPE_TRANSPORT, 'ProxyTransport::init');
+
+    this.driver.init();
+  }
+}
+
+class SocketTransport extends Transport {
+  constructor(config = {}) {
+    log(TYPE_TRANSPORT, 'SocketTransport::constructor', config);
+
+    super();
+
+    this.driver = config.driver || null;
+    this.host = config.host || null;
+    this.port = config.port || null;
+    this.secure = config.secure || false;
+
+    this.driver.bind(Driver.ON_READY, this._handleDriverReady.bind(this));
+    this.driver.bind(Driver.ON_MESSAGE, this._handleDriverMessage.bind(this));
+    this.driver.bind(
+      Driver.ON_CONNECTED,
+      this._handleDriverConnected.bind(this),
+    );
+    this.driver.bind(
+      Driver.ON_DISCONNECTED,
+      this._handleDriverDisconnected.bind(this),
+    );
+  }
+
+  _handleDriverReady() {
+    log(TYPE_TRANSPORT, 'SocketTransport::_handleDriverReady');
+
+    this.trigger(SocketTransport.ON_READY);
+  }
+
+  _handleDriverMessage(message) {
+    log(TYPE_TRANSPORT, 'SocketTransport::handleDriverMessage');
+
+    this.trigger(SocketTransport.ON_MESSAGE, message);
+  }
+
+  _handleDriverConnected() {
+    log(TYPE_TRANSPORT, 'SocketTransport::handleDriverConnected');
+
+    this.state = SocketTransport.STATE_CONNECTED;
+    this.trigger(SocketTransport.ON_CONNECTED);
+  }
+
+  _handleDriverDisconnected() {
+    log(
+      TYPE_TRANSPORT,
+      'SocketTransport::handleDriverDisconnected',
+    );
+
+    const { state } = this;
+
+    this.state = SocketTransport.STATE_DISCONNECTED;
+
+    switch (state) {
+      case SocketTransport.STATE_CONNECTED:
+        this.trigger(SocketTransport.ON_CONNECT_LOST);
+        break;
+      case SocketTransport.STATE_CONNECTING:
+        this.trigger(SocketTransport.ON_CONNECT_FAILED);
+        break;
+      case SocketTransport.STATE_DISCONNECTING:
+        this.trigger(SocketTransport.ON_DISCONNECTED);
+        break;
+    }
+  }
+
+  send(sscp, success = () => {}, failure = () => {}) {
+    log(TYPE_TRANSPORT, 'SocketTransport::send', sscp);
+    this.driver.send(sscp, success, failure);
+  }
+
+  connect() {
+    log(
+      TYPE_TRANSPORT,
+      'SocketTransport::connect',
+      this.host,
+      this.port,
+    );
+    this.state = SocketTransport.STATE_CONNECTING;
+    this.driver.connect(this.host, this.port, this.secure);
+  }
+
+  disconnect() {
+    log(TYPE_TRANSPORT, 'SocketTransport::disconnect');
+    this.state = SocketTransport.STATE_DISCONNECTING;
+    this.driver.disconnect();
+  }
+
+  init() {
+    log(TYPE_TRANSPORT, 'SocketTransport::init');
+    this.driver.init();
+  }
+}
+
+const METHOD_PROXY = 'proxy';
+const METHOD_WEBSOCKET = 'websocket';
+
+class TransportManager extends sdkUtil.Emitter {
+  constructor() {
+    super();
+
+    this.trigger = this.emit;
+    this.bind = this.on;
+    this.unbind = this.off;
+
+    this.ON_READY = 'ready';
+    this.config = null;
+    this.idx = 0;
+
+    // list of connection types pairs: transport - driver
+    this.methods = {};
+    this.transports = {};
+    this.loaded = 0;
+    this.sequence = [];
+    this.allowed = [];
+    this.secure = true;
+
+    // Guarding the use of the window object in environments where it might
+    // not be available, such as during server - side rendering in a framework
+    // like Next.js
+    if (typeof window !== 'undefined') {
+      this.secure = window.location.protocol.indexOf('https') === 0;
+    }
+
+    // list of connection methods which where unsuccessful
+    this.unsuccessful = [];
+  }
+
+  _instantiate() {
+    log(TYPE_MANAGER, 'TransportManager::instantiate');
+
+    // instantiate all transports
+    this.allowed.forEach((method) => {
+      const config = this._getMethodConfig(method);
+
+      // pick the random host
+      const host =
+        config.hosts[Math.floor(Math.random() * config.hosts.length)];
+
+      const TransportKlass = this.methods[method].transport;
+      const DriverKlass = this.methods[method].driver;
+
+      const transport = new TransportKlass({
+        driver: new DriverKlass(config.driver || {}),
+        host,
+        port: this.secure ? config.secure_port : config.port,
+        secure: this.secure,
+      });
+
+      this.transports[method] = transport;
+
+      transport.bind(Transport.ON_READY, this._handleTransportReady.bind(this));
+    }, this);
+
+    // initialise all transports
+    for (const method in this.transports) {
+      if (Object.prototype.hasOwnProperty.call(this.transports, method)) {
+        this.transports[method].init();
+      }
+    }
+  }
+
+  _getMethodConfig(method) {
+    return this.config.methods.find((item) => item.type === method);
+  }
+
+  _handleTransportReady() {
+    this.loaded += 1;
+
+    if (this.loaded === this.allowed.length) {
+      this.trigger(this.ON_READY);
+    }
+  }
+
+  current() {
+    return this.transports[this.allowed[this.idx]];
+  }
+
+  next() {
+    this.idx += 1;
+
+    if (this.idx >= this.allowed.length) {
+      return false;
+    }
+
+    return this.current();
+  }
+
+  reset() {
+    this.allowed = [];
+    this.unsuccessful = [];
+
+    // gather all methods in one array in correct connection sequence
+    for (let i = 0, l = this.sequence.length; i < l; i += 1) {
+      // shift method's idx by the value of the current method idx
+      const method = this.sequence[(i + this.idx) % l];
+
+      if (this.methods[method].driver.hasSupport()) {
+        this.allowed.push(method);
+      }
+    }
+
+    this.idx = 0;
+  }
+
+  addUnsuccessful(transport) {
+    for (const method in this.transports) {
+      if (
+        Object.prototype.hasOwnProperty.call(this.transports, method) &&
+        this.transports[method] === transport
+      ) {
+        this.unsuccessful.push(method);
+      }
+    }
+  }
+
+  init(config = {}) {
+    this.config = config;
+    this.idx = 0;
+    this.loaded = 0;
+    this.sequence = [];
+    this.secure = config.forceSecure === true ? true : this.secure;
+
+    this.methods[METHOD_PROXY] = {
+      driver: XHRDriver,
+      transport: ProxyTransport,
+    };
+    this.methods[METHOD_WEBSOCKET] = {
+      driver: WebSocketDriver,
+      transport: SocketTransport,
+    };
+
+    if (ENMASSE_OVERRIDE_METHODS) {
+      this.sequence = ENMASSE_OVERRIDE_METHODS;
+    } else {
+      this.config.methods.forEach(
+        (method) => this.sequence.push(method.type),
+        this,
+      );
+    }
+
+    // remove unsupported methods
+    /* eslint-disable */
+    this.sequence = this.sequence.filter((item) =>
+      Object.prototype.hasOwnProperty.call(this.methods, item),
+    );
+    /* eslint-enable */
+
+    this.reset();
+
+    this._instantiate();
+  }
+}
+
+var TransportManager$1 = new TransportManager();
+
+/* eslint @typescript-eslint/no-use-before-define: ["error", { "variables": false }] */
+
+const ConnectionManager = (() => {
+  const self = new sdkUtil.Emitter();
+
+  self.trigger = self.emit;
+  self.bind = self.on;
+  self.unbind = self.off;
+
+  /*
+   * Constants
+   */
+  const CONNECT_DELAYS = [0, 3, 5, 10, 20, 30, 45, 60];
+
+  /*
+   * States
+   */
+  self.STATE_DISCONNECTED = 'state_disconnected';
+  self.STATE_DISCONNECTING = 'state_disconnecting';
+  self.STATE_CONNECTING = 'state_connecting';
+  self.STATE_CONNECTED = 'state_connected';
+
+  /*
+   * Events
+   */
+  self.ON_MESSAGE = 'message';
+  self.ON_STATE = 'state';
+
+  /*
+   * Private variables
+   */
+  let config = null;
+  let state = self.STATE_DISCONNECTED;
+  let transport = null;
+  let attempt = 1;
+
+  // Timestamp to track when the app was backgrounded
+  let backgroundedAt = null;
+
+  const inactivityTimeout = {
+    start() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::inactivityTimeout::start',
+      );
+
+      const stamp = now();
+
+      this.interval = setInterval(() => {
+        if (now() - stamp >= config.inactivity_timeout) {
+          this.resolve();
+        }
+      }, 1000);
+    },
+
+    stop() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::inactivityTimeout::stop',
+      );
+
+      clearInterval(this.interval);
+    },
+
+    reset() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::inactivityTimeout::reset',
+      );
+
+      this.stop();
+      this.start();
+    },
+
+    resolve() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::inactivityTimeout::resolve',
+      );
+
+      disconnectingOnConnectLost();
+    },
+  };
+
+  const connectTimeout = {
+    start() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectTimeout::start',
+      );
+
+      this.timeout = setTimeout(() => {
+        this.resolve();
+      }, config.connect_timeout * 1000);
+    },
+
+    stop() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectTimeout::stop',
+      );
+
+      clearTimeout(this.timeout);
+    },
+
+    resolve() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectTimeout::resolve',
+      );
+
+      disconnectingOnConnectFailed();
+    },
+  };
+
+  const connectDelay = {
+    active: false,
+
+    start(delay) {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectDelay::start',
+      );
+
+      this.active = true;
+      this.timeout = setTimeout(() => {
+        this.resolve();
+      }, delay * 1000);
+    },
+
+    stop() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectDelay::stop',
+      );
+
+      this.active = false;
+      clearTimeout(this.timeout);
+    },
+
+    resolve() {
+      log(
+        TYPE_MANAGER_EXTRA,
+        'ConnectionManager::connectDelay::resolve',
+      );
+
+      this.stop();
+      connect();
+    },
+  };
+
+  const initTransport = (newTransport) => {
+    log(TYPE_MANAGER, 'ConnectionManager::initTransport');
+
+    transport = newTransport;
+
+    transport.bind(Transport.ON_MESSAGE, handleTransportMessage);
+    transport.bind(Transport.ON_CONNECTED, handleTransportConnected);
+    transport.bind(Transport.ON_CONNECT_FAILED, handleTransportConnectFailed);
+    transport.bind(Transport.ON_CONNECT_LOST, handleTransportConnectLost);
+    transport.bind(Transport.ON_DISCONNECTED, handleTransportDisconnected);
+  };
+
+  const teardownTransport = () => {
+    log(TYPE_MANAGER, 'ConnectionManager::teardownTransport');
+
+    if (transport === null) {
+      return;
+    }
+
+    transport.unbind(Transport.ON_MESSAGE, handleTransportMessage);
+    transport.unbind(Transport.ON_CONNECTED, handleTransportConnected);
+    transport.unbind(Transport.ON_CONNECT_FAILED, handleTransportConnectFailed);
+    transport.unbind(Transport.ON_CONNECT_LOST, handleTransportConnectLost);
+    transport.unbind(Transport.ON_DISCONNECTED, handleTransportDisconnected);
+
+    transport = null;
+  };
+
+  const handleTransportMessage = (message) => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleTransportMessage',
+      message,
+    );
+
+    const messages = message.split('\0');
+
+    for (let i = 0; i < messages.length; i += 1) {
+      if (messages[i].length > 0) {
+        inactivityTimeout.reset();
+        log(
+          TYPE_MANAGER,
+          'ConnectionManager::handleTransportMessage',
+          'send upstream m:',
+          messages[i],
+        );
+        self.trigger(self.ON_MESSAGE, messages[i]);
+      }
+    }
+  };
+
+  const handleTransportConnected = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleTransportConnected',
+    );
+    setStateToConnected();
+  };
+
+  const handleTransportConnectFailed = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleTransportConnectFailed',
+    );
+    disconnectingOnConnectFailed();
+  };
+
+  const handleTransportConnectLost = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleTransportConnectLost',
+    );
+    disconnectingOnConnectLost();
+  };
+
+  const handleTransportDisconnected = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleTransportDisconnected',
+    );
+
+    switch (state) {
+      case self.STATE_CONNECTED:
+        disconnectedOnConnectLost();
+        break;
+      case self.STATE_CONNECTING:
+        disconnectedOnConnectFailed();
+        break;
+      case self.STATE_DISCONNECTING:
+        setStateToDisconnected();
+        break;
+    }
+  };
+
+  const disconnectingOnConnectFailed = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::disconnectingOnConnectFailed()',
+    );
+
+    disconnect();
+  };
+
+  const disconnectingOnConnectLost = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::disconnectingOnConnectLost()',
+    );
+
+    disconnect();
+  };
+
+  const disconnectedOnConnectLost = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::disconnectedOnConnectLost()',
+    );
+
+    teardownTransport();
+
+    // automatically reconnect
+    setStateToConnecting();
+  };
+
+  const disconnectedOnConnectFailed = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::disconnectedOnConnectFailed()',
+    );
+
+    TransportManager$1.addUnsuccessful(transport);
+
+    teardownTransport();
+
+    if (TransportManager$1.next() === false) {
+      setStateToConnecting();
+    } else {
+      connect();
+    }
+  };
+
+  const setStateToConnecting = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::setStateToConnecting()',
+    );
+
+    let delay;
+
+    if (attempt >= CONNECT_DELAYS.length) {
+      delay = CONNECT_DELAYS[CONNECT_DELAYS.length - 1];
+    } else {
+      delay = CONNECT_DELAYS[attempt - 1];
+    }
+
+    state = self.STATE_CONNECTING;
+    self.trigger(self.ON_STATE, state, attempt, delay);
+
+    TransportManager$1.reset();
+
+    attempt += 1;
+    connectDelay.start(delay);
+  };
+
+  const setStateToConnected = () => {
+    log(TYPE_MANAGER, 'ConnectionManager::setStateToConnected()');
+
+    attempt = 1;
+    TransportManager$1.reset();
+    inactivityTimeout.reset();
+    connectTimeout.stop();
+    connectDelay.stop();
+
+    state = self.STATE_CONNECTED;
+    self.trigger(self.ON_STATE, state);
+  };
+
+  const setStateToDisconnecting = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::setStateToDisconnecting()',
+    );
+
+    state = self.STATE_DISCONNECTING;
+    self.trigger(self.ON_STATE, state);
+
+    disconnect();
+  };
+
+  const setStateToDisconnected = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::setStateToDisconnected()',
+    );
+
+    attempt = 1;
+    teardownTransport();
+    TransportManager$1.reset();
+
+    state = self.STATE_DISCONNECTED;
+    self.trigger(self.ON_STATE, state);
+  };
+
+  const connect = () => {
+    if (state === self.STATE_CONNECTING) {
+      connectTimeout.start();
+      initTransport(TransportManager$1.current());
+      transport.connect();
+    }
+  };
+
+  const disconnect = () => {
+    inactivityTimeout.stop();
+    connectTimeout.stop();
+    connectDelay.stop();
+
+    if (transport) {
+      transport.disconnect();
+    } else {
+      setStateToDisconnected();
+    }
+  };
+
+  /**
+   * Handles changes in the document's visibility state (visible/hidden).
+   *
+   * - Tracks when the document is backgrounded by recording the timestamp.
+   * - When the document becomes visible again, checks if the time spent in the background
+   *   exceeds a configured timeout. If it does, the connection is disconnected.
+   * - Ensures actions are only taken if necessary, based on the current connection state
+   *   and whether the page was previously backgrounded.
+   *
+   * Note on Safari (ios and desktop) and Firefox quirk: visibilitychange event is fired
+   * immidiately when the page is loaded, even if the page is visible.
+   */
+  const handleVisibilityChange = () => {
+    log(
+      TYPE_MANAGER,
+      'ConnectionManager::handleVisibilityChange()',
+      document.visibilityState,
+    );
+
+    switch (document.visibilityState) {
+      case 'visible':
+        if (backgroundedAt === null) {
+          return;
+        }
+
+        if (state !== self.STATE_CONNECTED) {
+          return;
+        }
+
+        if (Date.now() - backgroundedAt > config.background_timeout * 1000) {
+          log(
+            TYPE_MANAGER,
+            'ConnectionManager::handleVisibilityChange()',
+            'disconnecting due to background timeout',
+          );
+
+          disconnect();
+        }
+
+        backgroundedAt = null;
+        break;
+      case 'hidden':
+        backgroundedAt = Date.now();
+        break;
+    }
+  };
+
+  const handleNetworkStatus = () => {
+    if (!navigator.onLine && state === self.STATE_CONNECTED) {
+      log(
+        TYPE_MANAGER,
+        'ConnectionManager::handleNetworkStatus()',
+        'disconnecting due to network loss',
+      );
+      disconnect();
+    }
+  };
+
+  self.connect = () => {
+    log(TYPE_MANAGER, 'ConnectionManager::connect()');
+
+    // resolve connect instantly if the process has been already postponed
+    if (connectDelay.active) {
+      connectDelay.resolve();
+    } else if (state === self.STATE_DISCONNECTED) {
+      setStateToConnecting();
+    }
+
+    window.addEventListener('online', handleNetworkStatus);
+    window.addEventListener('offline', handleNetworkStatus);
+    window.addEventListener('visibilitychange', handleVisibilityChange);
+  };
+
+  self.disconnect = () => {
+    log(TYPE_MANAGER, 'ConnectionManager::disconnect()');
+
+    setStateToDisconnecting();
+
+    window.removeEventListener('online', handleNetworkStatus);
+    window.removeEventListener('offline', handleNetworkStatus);
+    window.removeEventListener('visibilitychange', handleVisibilityChange);
+  };
+
+  self.send = (sscp, success, failure) => {
+    log(TYPE_MANAGER, 'ConnectionManager::send', sscp);
+    success = success || (() => {});
+    failure = failure || (() => {});
+    transport.send(sscp, success, failure);
+  };
+
+  self.getConnectAttempt = () => attempt;
+
+  self.init = (cfg) => {
+    log(TYPE_MANAGER, 'ConnectionManager::init()', cfg);
+    config = cfg;
+  };
+
+  return self;
+})();
+
+/* eslint-disable no-console */
+
+class Demographics extends sdkUtil.Emitter {
+  constructor(...args) {
+    super(...args);
+
+    this.ON_ADD_COUNTER = 'add-counter';
+
+    this.trigger = this.emit;
+    this.bind = this.on;
+    this.unbind = this.off;
+  }
+
+  addCounter(
+    channel,
+    eventId,
+    segment,
+    counter,
+    round = null,
+    min = null,
+    max = null,
+  ) {
+    log(
+      TYPE_SERVICE,
+      'Demographics::addCounter',
+      channel,
+      eventId,
+      segment,
+      counter,
+      round,
+      min,
+      max,
+    );
+
+    if (!channel) {
+      return;
+    }
+
+    if (!eventId) {
+      return;
+    }
+
+    if (
+      !segment ||
+      segment.constructor !== Array ||
+      !segment.length ||
+      segment.length % 2 !== 0
+    ) {
+      return;
+    }
+
+    if (counter !== parseInt(counter, 10)) {
+      return;
+    }
+
+    const keys = segment.filter((v, i) => (i + 1) % 2).join(':');
+    const values = segment.filter((v, i) => i % 2).join(':');
+
+    this.trigger(this.ON_ADD_COUNTER, channel, [
+      eventId,
+      min,
+      max,
+      round,
+      keys,
+      values,
+      counter,
+    ]);
+  }
+}
+
+var Demographics$1 = new Demographics();
+
+/* eslint-disable no-console */
+
+const Enmasse = (() => {
+  /*
+   * Link to the scope
+   */
+
+  const self = new sdkUtil.Emitter();
+
+  self.trigger = self.emit;
+  self.bind = self.on;
+  self.unbind = self.off;
+
+  /*
+   * Constants
+   */
+
+  self.VERSION = version;
+  self.PROTOCOL_VERSION = '8';
+
+  self.SSCP_KLASS_AUTH = SSCP_KLASS_AUTH;
+  self.SSCP_KLASS_AUTHR = SSCP_KLASS_AUTHR;
+  self.SSCP_KLASS_AUTHOK = SSCP_KLASS_AUTHOK;
+  self.SSCP_KLASS_PING = SSCP_KLASS_PING;
+  self.SSCP_KLASS_SUB = SSCP_KLASS_SUB;
+  self.SSCP_KLASS_UNSUB = SSCP_KLASS_UNSUB;
+  self.SSCP_KLASS_EOC = SSCP_KLASS_EOC;
+  self.SSCP_KLASS_LOGIN = SSCP_KLASS_LOGIN;
+  self.SSCP_KLASS_LOGOUT = SSCP_KLASS_LOGOUT;
+  self.SSCP_KLASS_COUNTER = SSCP_KLASS_COUNTER;
+
+  self.ON_STATE = 'on_state';
+  self.ON_MESSAGE = 'on_message';
+  self.ON_EOC = 'on_eoc';
+  self.ON_READY = 'on_ready';
+  self.ON_ERROR = 'on_error';
+
+  self.STATE_DISCONNECTED = 'disconnected';
+  self.STATE_CONNECTED = 'connected';
+  self.STATE_CONNECTING = 'connecting';
+
+  self.Demographics = Demographics$1;
+
+  // var CALLBACK_NAME       = "__enmasse_callback";
+  // var CONFIG_TIMEOUT      = 5000;
+
+  const PARAM_SESSION_ID = 'enmasse_session_id';
+
+  /*
+   * Enmasse properties
+   */
+
+  // Link to the config file.
+  let configFile = null;
+
+  // list of arbitray data passed into handshake
+  // message along with the protocol version
+  let info = [];
+
+  // session id is generated by server and passed
+  // on client on handshake
+  let sessionId = null;
+
+  // out messages queue
+  let queue = null;
+
+  // current state of the state machine
+  let state = self.STATE_DISCONNECTED;
+
+  // system channel
+  let sysChannel = null;
+
+  // force secure connection
+  let forceSecure = false;
+
+  // sign in promise object
+  let loginContext = {
+    inProgress: false,
+    success: () => {},
+    failure: () => {},
+  };
+
+  /*
+   * Private methods
+   */
+
+  const storeSession = async (id) => {
+    try {
+      await sdkStorageKit.storageWrite(PARAM_SESSION_ID, id);
+    } catch (err) {
+      console.error(
+        `Failed to persist session to shared storage: ${sdkUtil.getErrorMessage(err)}`,
+      );
+    }
+  };
+
+  const restoreSession = async () => {
+    let restoredId = null;
+
+    // Read session from shared storage
+    try {
+      restoredId = await sdkStorageKit.storageRead(PARAM_SESSION_ID);
+    } catch (err) {
+      console.error(
+        `Failed to read session from shared storage: ${sdkUtil.getErrorMessage(err)}`,
+      );
+    }
+
+    if (restoredId !== null) {
+      return restoredId;
+    }
+
+    /**
+     * Further down is a special case when we try to restore session id from the
+     * local storage and save it to the shared storage. This could happen in
+     * previous versions of the SDK when we didn't have a shared storage.
+     */
+
+    if (sdkLauncherKit.getParentApplication() === null) {
+      return null;
+    }
+
+    try {
+      restoredId = sdkUtil.getItem(PARAM_SESSION_ID);
+    } catch (err) {
+      console.error(
+        `Failed to read local session during migration: ${sdkUtil.getErrorMessage(
+          err,
+        )}`,
+      );
+    }
+
+    if (restoredId === null) {
+      return null;
+    }
+
+    try {
+      await sdkStorageKit.storageWrite(PARAM_SESSION_ID, restoredId);
+    } catch (err) {
+      console.error(
+        `Failed to persist session to shared storage during migration: ${sdkUtil.getErrorMessage(
+          err,
+        )}`,
+      );
+    }
+
+    return restoredId;
+  };
+
+  const resetSession = async () => {
+    sessionId = null;
+
+    try {
+      await sdkStorageKit.storageRemove(PARAM_SESSION_ID);
+    } catch (err) {
+      console.error(
+        `Failed to remove session from shared storage: ${sdkUtil.getErrorMessage(err)}`,
+      );
+    }
+  };
+
+  const validateSession = (id) =>
+    // eslint-disable-next-line
+    /^[a-f\d]{8}\-[a-f\d]{4}\-[a-f\d]{4}-[a-f\d]{4}\-[a-f\d]{12}$/i.test(id);
+
+  const finaliseLogin = (callback) => {
+    if (loginContext.inProgress === false) {
+      return;
+    }
+
+    loginContext = {
+      inProgress: false,
+      success: () => {},
+      failure: () => {},
+    };
+
+    callback();
+  };
+
+  const resolveLogin = () => {
+    finaliseLogin(loginContext.success);
+  };
+
+  const rejectLogin = () => {
+    finaliseLogin(loginContext.failure);
+  };
+
+  const setStateToDisconnected = () => {
+    log(TYPE_PROTOCOL, 'Enmasse::setStateToDisconnected()');
+
+    state = self.STATE_DISCONNECTED;
+    sysChannel = null;
+
+    rejectLogin();
+
+    self.trigger(self.ON_STATE, state);
+  };
+
+  const setStateToConnected = () => {
+    log(TYPE_PROTOCOL, 'Enmasse::setStateToConnected()');
+
+    const time = now();
+    state = self.STATE_CONNECTED;
+    self.trigger(self.ON_STATE, state, time);
+  };
+
+  const setStateToConnecting = (attempt, delay) => {
+    log(TYPE_PROTOCOL, 'Enmasse::setStateToConnecting()');
+
+    state = self.STATE_CONNECTING;
+    rejectLogin();
+
+    self.trigger(self.ON_STATE, state, attempt, delay);
+  };
+
+  const parseSSCP = (sscp) => {
+    const data = {
+      channel: 0,
+      klass: '',
+      sent_at: 0,
+      body: [],
+    };
+
+    const separator1 = sscp.indexOf('/');
+
+    if (separator1 !== -1) {
+      const separator2 = sscp.indexOf('/', separator1 + 1);
+
+      if (separator2 !== -1) {
+        data.channel = sscp.substr(0, separator1);
+        data.klass = sscp.substr(separator1 + 1, separator2 - separator1 - 1);
+
+        const separator3 = sscp.indexOf('/', separator2 + 1);
+
+        if (separator3 !== -1) {
+          data.sent_at = parseInt(
+            sscp.substr(separator2 + 1, separator3 - separator2 - 1),
+            10,
+          );
+
+          const body = sscp.substr(separator3 + 1);
+
+          if (body !== '') {
+            const values = body.split('|');
+
+            for (let i = 0, l = values.length; i < l; i += 1) {
+              data.body[i] = decodeURIComponent(values[i]);
+            }
+          }
+        }
+      }
+    }
+
+    return data;
+  };
+
+  const stringifySSCP = (message) =>
+    [
+      message.channel,
+      message.klass,
+      Math.floor(new Date() / 1000),
+      message.body.join('|'),
+    ].join('/');
+
+  const runner = (message) => {
+    const success = () => {
+      queue.success();
+    };
+
+    const failure = () => {
+      queue.failure();
+    };
+
+    ConnectionManager.send(stringifySSCP(message), success, failure);
+  };
+
+  const handleTransportManagerReady = () => {
+    log(TYPE_PROTOCOL, 'Enmasse::handleTransportManagerReady');
+    self.trigger(self.ON_READY);
+  };
+
+  const handleConnectionManagerState = (...args) => {
+    log(
+      TYPE_PROTOCOL,
+      'Enmasse::handleConnectionManagerState',
+      args,
+    );
+
+    switch (args[0]) {
+      // case ConnectionManager.STATE_DISCONNECTING:
+      // break;
+      case ConnectionManager.STATE_DISCONNECTED:
+        setStateToDisconnected();
+        break;
+      case ConnectionManager.STATE_CONNECTING:
+        setStateToConnecting(args[1], args[2]);
+        break;
+      case ConnectionManager.STATE_CONNECTED:
+        break;
+    }
+  };
+
+  const handleConnectionManagerMessage = async (message) => {
+    log(
+      TYPE_PROTOCOL,
+      'Enmasse::handleConnectionManagerMessage',
+      message,
+    );
+
+    const data = parseSSCP(message);
+
+    switch (data.klass) {
+      case SSCP_KLASS_AUTH: {
+        const time = data.sent_at;
+
+        const clientInfo = [
+          `enmassejs-${self.VERSION}`,
+          navigator.userAgent,
+        ].concat(info);
+
+        // store system channel
+        sysChannel = data.channel;
+
+        // url encode each client info item
+        clientInfo.forEach((item, idx) => {
+          clientInfo[idx] = encodeURIComponent(item);
+        });
+
+        if (sessionId === null) {
+          [sessionId] = data.body;
+          await storeSession(sessionId);
+        }
+
+        setTime(time);
+
+        queue.stash();
+
+        queue.push(
+          {
+            channel: sysChannel,
+            klass: SSCP_KLASS_AUTHR,
+            body: [sessionId, self.PROTOCOL_VERSION, clientInfo.join(',')],
+          },
+          true,
+        );
+
+        queue.run();
+
+        break;
+      }
+      case SSCP_KLASS_AUTHOK: {
+        // We have to resubscribe to the previously
+        // subscribed channels after the reconnect.
+        const subscriptions = queue.getSubscriptions();
+
+        subscriptions.forEach((channel) => {
+          queue.push(
+            {
+              channel,
+              klass: SSCP_KLASS_SUB,
+              body: [],
+            },
+            true,
+          );
+        });
+
+        queue.unstash();
+        queue.run();
+
+        setStateToConnected();
+        break;
+      }
+      case SSCP_KLASS_LOGIN_OK:
+        resolveLogin();
+        break;
+      case SSCP_KLASS_LOGIN_FAIL:
+        rejectLogin();
+        break;
+      case SSCP_KLASS_PING:
+        // ignoring ping message handling
+        break;
+      case SSCP_KLASS_EOC:
+        self.trigger(self.ON_EOC, data.channel);
+        break;
+      default:
+        self.trigger(self.ON_MESSAGE, data);
+        break;
+    }
+  };
+
+  const handleDemographicsCounter = (channel, data) => {
+    self.send(channel, 'avgcounter', data);
+  };
+
+  /**
+   * @internal
+   */
+  self.PARAM_SESSION_ID = PARAM_SESSION_ID;
+
+  /**
+   * @internal
+   */
+  self.resetSession = resetSession;
+
+  /*
+   * Public methods
+   */
+
+  self.connect = () => {
+    log(TYPE_PROTOCOL, 'Enmasse::connect');
+
+    ConnectionManager.connect();
+  };
+
+  self.disconnect = () => {
+    log(TYPE_PROTOCOL, 'Enmasse:disconnect');
+
+    ConnectionManager.disconnect();
+  };
+
+  self.send = (channel, klass, body) => {
+    log(TYPE_PROTOCOL, 'Enmasse::send', channel, klass, body);
+
+    body = body || [];
+
+    queue.push({
+      channel,
+      klass,
+      body,
+    });
+
+    if (state === self.STATE_CONNECTED) {
+      queue.run();
+    }
+  };
+
+  self.getSessionId = () => sessionId;
+
+  self.getState = () => state;
+
+  self.subscribe = (channel) => {
+    self.send(channel, SSCP_KLASS_SUB);
+  };
+
+  self.unsubscribe = (channel) => {
+    self.send(channel, SSCP_KLASS_UNSUB);
+  };
+
+  self.login = (
+    userId,
+    timestamp,
+    signature,
+    success = () => {},
+    failure = () => {},
+  ) => {
+    if (sysChannel === null) {
+      return;
+    }
+
+    if (loginContext.inProgress) {
+      console.warn('Login is already in progress');
+      return;
+    }
+
+    loginContext = { inProgress: true, success, failure };
+
+    self.send(sysChannel, SSCP_KLASS_LOGIN, [userId, timestamp, signature]);
+  };
+
+  self.logout = () => {
+    if (sysChannel === null) {
+      return;
+    }
+
+    if (loginContext.inProgress) {
+      rejectLogin();
+    }
+
+    self.send(sysChannel, SSCP_KLASS_LOGOUT);
+  };
+
+  self.init = async function init(config = () => {}) {
+    // config file is passed either as GET parameter or via constructor
+    configFile = !ENMASSE_CONFIG ? config.config || null : ENMASSE_CONFIG;
+    info = config.info || [];
+    sessionId = await restoreSession();
+
+    if (typeof config.forceSecure === 'boolean') {
+      forceSecure = config.forceSecure;
+    }
+
+    if (configFile === null) {
+      // eslint-disable-next-line
+      throw 'EnMasse config file is not set';
+    }
+
+    // If session id has invalid format
+    if (sessionId !== null && !validateSession(sessionId)) {
+      await resetSession();
+    }
+
+    queue = new Queue({
+      runner,
+    });
+
+    TransportManager$1.bind(
+      TransportManager$1.ON_READY,
+      handleTransportManagerReady,
+    );
+    ConnectionManager.bind(
+      ConnectionManager.ON_STATE,
+      handleConnectionManagerState,
+    );
+    ConnectionManager.bind(
+      ConnectionManager.ON_MESSAGE,
+      handleConnectionManagerMessage,
+    );
+    Demographics$1.bind(Demographics$1.ON_ADD_COUNTER, handleDemographicsCounter);
+
+    try {
+      const response = await fetch(configFile);
+
+      const { status, statusText: text } = response;
+
+      let data;
+
+      try {
+        data = await response.json();
+      } catch (jsonErr) {
+        self.trigger(self.ON_ERROR, `Invalid JSON from config ${configFile}`);
+        return;
+      }
+
+      const isSuccess =
+        (status >= 200 && status <= 300) ||
+        // If you conclude with an XMLHttpRequest receiving status=0 and
+        // statusText=null, this means the request was not allowed to be
+        // performed.
+        // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#xmlhttprequests_being_stopped
+        (status === 0 && !!text) ||
+        status === '';
+
+      data.forceSecure = forceSecure;
+
+      if (data.background_timeout === undefined) {
+        data.background_timeout = 0;
+      }
+
+      if (isSuccess) {
+        ConnectionManager.init(data);
+        TransportManager$1.init(data);
+      } else {
+        self.trigger(self.ON_ERROR, `Failed to load config ${configFile}`);
+      }
+    } catch (err) {
+      self.trigger(self.ON_ERROR, `Error loading config: ${err.message}`);
+    }
+  };
+
+  return self;
+})();
+
+module.exports = Enmasse;
+//# sourceMappingURL=index.cjs.map