@jibb-open/jssdk 3.5.8 → 3.5.10

package/ws/ipsa.js

@@ -0,0 +1,262 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IPSA = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.array-buffer.constructor.js");
+require("core-js/modules/es.array-buffer.slice.js");
+require("core-js/modules/es.typed-array.uint8-array.js");
+require("core-js/modules/es.typed-array.fill.js");
+require("core-js/modules/es.typed-array.set.js");
+require("core-js/modules/es.typed-array.sort.js");
+require("core-js/modules/es.typed-array.to-locale-string.js");
+var _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _retry_connection = require("./retry_connection.js");
+var _connection_base = require("./connection_base.js");
+var _types = require("../types/types.js");
+var _proto = require("../types/proto.js");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+const ErrorCode = _proto.types.Code;
+var _expiryTimer = /*#__PURE__*/new WeakMap();
+var _clear = /*#__PURE__*/new WeakSet();
+var _write = /*#__PURE__*/new WeakSet();
+var _handleMessage = /*#__PURE__*/new WeakSet();
+var _onResponse = /*#__PURE__*/new WeakSet();
+var _writeInputImage = /*#__PURE__*/new WeakSet();
+var _setConfig = /*#__PURE__*/new WeakSet();
+class IPSAClass extends _retry_connection.RetryConnection {
+  constructor() {
+    super('ipsa');
+    _classPrivateMethodInitSpec(this, _setConfig);
+    _classPrivateMethodInitSpec(this, _writeInputImage);
+    _classPrivateMethodInitSpec(this, _onResponse);
+    _classPrivateMethodInitSpec(this, _handleMessage);
+    _classPrivateMethodInitSpec(this, _write);
+    _classPrivateMethodInitSpec(this, _clear);
+    _classPrivateFieldInitSpec(this, _expiryTimer, {
+      writable: true,
+      value: void 0
+    });
+    this.socket = null;
+    this.onInputImage = null;
+    this.onError = null;
+    this.onResponse = null;
+    this.userToken = null;
+    _classPrivateFieldSet(this, _expiryTimer, null);
+    _classPrivateMethodGet(this, _clear, _clear2).call(this);
+  }
+  start(_ref) {
+    let {
+      userToken,
+      request,
+      onInputImage,
+      onError,
+      onResponse
+    } = _ref;
+    if (!this.isStarted()) {
+      this.setRuntimeConfig(request.runtimeConfig);
+      this.setAppConfig(request.appConfig);
+      _classPrivateMethodGet(this, _setConfig, _setConfig2).call(this, request.config);
+      this.onInputImage = onInputImage;
+      this.onError = onError;
+      this.onResponse = onResponse;
+      this.userToken = userToken;
+      let meetingClaims = new _types.MeetingClaims(this.appConfigRequest.appConfig.meetingToken);
+      let userClaims = new _types.UserClaims(this.userToken);
+      let seconds = Math.min(userClaims.getSecondsUntilExpiry(), meetingClaims.getSecondsUntilExpiry());
+      if (seconds <= 0) {
+        this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      } else {
+        _classPrivateFieldSet(this, _expiryTimer, setTimeout(() => {
+          this.stop();
+          this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        }, seconds));
+      }
+    }
+    super.start();
+  }
+  stop() {
+    clearTimeout(_classPrivateFieldGet(this, _expiryTimer));
+    _classPrivateMethodGet(this, _clear, _clear2).call(this);
+    super.stop();
+  }
+  disconnect() {
+    super.disconnect();
+    if (this.socket != null) {
+      this.socket.close();
+      this.socket = null;
+      //  this.fireOnError(ErrorLevel.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+    }
+  }
+
+  async connect() {
+    if (this.getConnectionStatus() != _connection_base.ConnectionStatus.DISCONNECTED) return;
+    super.connect();
+    let meetingId = this.appConfigRequest.appConfig.meetingId;
+    let meetingToken = this.appConfigRequest.appConfig.meetingToken;
+    try {
+      let c = new _types.UserClaims(this.userToken);
+      if (c.isExpired()) {
+        this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      }
+    } catch (err) {
+      this.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+      return;
+    }
+    _index.logger.info("Connecting IPSA to meeting ".concat(meetingId, "..."));
+    let base = new URL(_config.Config.apiBaseURL);
+    let uri = "wss://".concat(base.hostname, "/ws/ipsa/").concat(meetingId, "?user_token=").concat(this.userToken, "&meeting_token=").concat(meetingToken);
+    this.socket = new WebSocket(uri);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", async () => {
+      try {
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.configRequest);
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.runtimeConfigRequest);
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.appConfigRequest);
+        this.onConnected();
+      } catch (err) {
+        this.onWarningMessage(ErrorCode.ERR_IO, err);
+        this.disconnect();
+        return;
+      }
+      let loopFunction = () => {
+        if (!this.isConnected() || !this.isStarted()) return;
+        if (this.socket.bufferedAmount > 0) {
+          _index.logger.warn("ipsa: low internet speed connection");
+          setTimeout(loopFunction, 100);
+        } else {
+          setTimeout(loopFunction, 500);
+          _classPrivateMethodGet(this, _writeInputImage, _writeInputImage2).call(this).catch(err => _index.logger.error(err));
+        }
+      };
+      loopFunction();
+    });
+    this.socket.addEventListener("close", () => {
+      this.onDisconnected();
+    });
+    this.socket.addEventListener("message", event => {
+      _classPrivateMethodGet(this, _handleMessage, _handleMessage2).call(this, event.data);
+    });
+    this.socket.addEventListener("error", err => {
+      this.onWarningMessage(ErrorCode.ERR_IO, err);
+    });
+  }
+  getAverageResponseTime() {
+    let avg = NaN;
+    try {
+      let items = Array.from(this.stats.values()).map(e => e.responseTime - e.requestTime).filter(e => !isNaN(e));
+      let sum = items.reduce((a, b) => a + b);
+      avg = sum / items.length;
+    } catch (err) {}
+    return avg;
+  }
+  setRuntimeConfig(cfg) {
+    let request = _proto.ipsa.Request.create({
+      runtimeConfig: cfg
+    });
+    this.runtimeConfigRequest = request;
+    if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+  }
+  setAppConfig(cfg) {
+    let request = _proto.ipsa.Request.create({
+      appConfig: cfg
+    });
+    this.appConfigRequest = request;
+    if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+  }
+}
+function _clear2() {
+  this.appConfigRequest = null;
+  this.configRequest = null;
+  this.runtimeConfigRequest = null;
+  this.stats = new Map();
+  this.requestId = 0;
+}
+async function _write2(msg) {
+  let err = _proto.ipsa.Request.verify(msg);
+  if (err) throw new Error("invalid message: " + err);
+  if (msg) {
+    let data = _proto.ipsa.Request.encode(msg).finish();
+    this.socket.send(data);
+  }
+}
+async function _handleMessage2(msg) {
+  var _msg, _msg2, _msg3, _msg4;
+  try {
+    if (msg instanceof ArrayBuffer) {
+      let buffer = new Uint8Array(msg);
+      let response = _proto.ipsa.Response.decode(buffer);
+      _classPrivateMethodGet(this, _onResponse, _onResponse2).call(this, response);
+      return;
+    }
+  } catch (err) {
+    _index.logger.error(err);
+  }
+  try {
+    msg = JSON.parse(msg);
+    switch (msg.code) {
+      case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+      case ErrorCode.ERR_UNAUTHORIZED:
+      case ErrorCode.ERR_BAD_REQUEST:
+        this.onErrorMessage((_msg = msg) === null || _msg === void 0 ? void 0 : _msg.code, (_msg2 = msg) === null || _msg2 === void 0 ? void 0 : _msg2.reason);
+        this.stop();
+        break;
+      default:
+        this.onInfoMessage((_msg3 = msg) === null || _msg3 === void 0 ? void 0 : _msg3.code, (_msg4 = msg) === null || _msg4 === void 0 ? void 0 : _msg4.reason);
+        break;
+    }
+  } catch (e) {
+    this.onWarningMessage(ErrorCode.ERR_IO, e);
+  }
+}
+function _onResponse2(response) {
+  if (response.id >= 100) {
+    let id = response.id - 100;
+    let s = this.stats.get(id) || {};
+    s.responseTime = performance.now();
+    this.stats.set(id, s);
+  }
+  if (this.onResponse) {
+    this.onResponse(response);
+  }
+}
+async function _writeInputImage2() {
+  let img = await this.onInputImage();
+  this.requestId = (this.requestId + 1) % 8;
+  this.stats.set(this.requestId, {
+    requestTime: performance.now()
+  });
+  let request = _proto.ipsa.Request.create({
+    id: this.requestId + 100,
+    ipsa: {
+      data: img
+    }
+  });
+  _classPrivateMethodGet(this, _write, _write2).call(this, request);
+}
+function _setConfig2(cfg) {
+  let request = _proto.ipsa.Request.create({
+    config: cfg
+  });
+  this.configRequest = request;
+  if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+}
+let IPSA = new IPSAClass();
+exports.IPSA = IPSA;

package/ws/meeting.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MeetingConnection = void 0;
+require("core-js/modules/es.global-this.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+require("core-js/modules/es.array-buffer.constructor.js");
+require("core-js/modules/es.array-buffer.slice.js");
+require("core-js/modules/es.typed-array.uint8-array.js");
+require("core-js/modules/es.typed-array.fill.js");
+require("core-js/modules/es.typed-array.set.js");
+require("core-js/modules/es.typed-array.sort.js");
+require("core-js/modules/es.typed-array.to-locale-string.js");
+var _auth = require("../api/auth.js");
+var _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _retry_connection = require("./retry_connection.js");
+var _connection_base = require("./connection_base.js");
+var _types = require("../types/types.js");
+var _proto = require("../types/proto.js");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+let Message = _proto.meeting.Message;
+let ErrorCode = _proto.types.Code;
+if ((globalThis === null || globalThis === void 0 ? void 0 : globalThis.WebSocket) == undefined) {
+  Promise.resolve().then(() => _interopRequireWildcard(require("isomorphic-ws"))).then(webSocket => {
+    globalThis.WebSocket = webSocket.default;
+  });
+}
+var _expiryTimer = /*#__PURE__*/new WeakMap();
+var _handleMessage = /*#__PURE__*/new WeakSet();
+class MeetingConnectionImp extends _retry_connection.RetryConnection {
+  constructor() {
+    super('meeting');
+    _classPrivateMethodInitSpec(this, _handleMessage);
+    _classPrivateFieldInitSpec(this, _expiryTimer, {
+      writable: true,
+      value: void 0
+    });
+    this.meetingId = null;
+    this.meetingToken = null;
+    _classPrivateFieldSet(this, _expiryTimer, null);
+  }
+  getName() {
+    return "".concat(super.getName(), "-").concat(this.meetingId);
+  }
+  async start(meetingToken) {
+    this.meetingToken = meetingToken;
+    this.meetingClaims = new _types.MeetingClaims(meetingToken);
+    this.meetingId = this.meetingClaims.meetindId;
+    let seconds = this.meetingClaims.getSecondsUntilExpiry();
+    if (seconds <= 0) {
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
+      return;
+    }
+    _classPrivateFieldSet(this, _expiryTimer, setTimeout(() => {
+      this.stop();
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
+    }, seconds));
+    super.start();
+  }
+  async stop() {
+    clearTimeout(_classPrivateFieldGet(this, _expiryTimer));
+    super.stop();
+  }
+  disconnect() {
+    if (this.socket != null) {
+      this.socket.close();
+      this.socket = null;
+      //	this.fireOnError(ErrorLevel.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+      _index.logger.info("meeting disconnect ", this.meetingId);
+    }
+    super.disconnect();
+  }
+  async connect() {
+    if (this.getConnectionStatus() != _connection_base.ConnectionStatus.DISCONNECTED) return;
+    super.connect();
+    let self = this;
+    try {
+      if (this.meetingClaims.isExpired()) {
+        self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
+        return;
+      }
+    } catch (e) {
+      self.onErrorMessage(ErrorCode.ERR_BAD_REQUEST, "invalid meeting token");
+      return;
+    }
+    let base = new URL(_config.Config.apiBaseURL);
+    let uri = "wss://" + base.hostname + "/ws/meetings/" + this.meetingId + "?meeting_token=" + this.meetingToken;
+    this.socket = new WebSocket(uri);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", function () {
+      self.onConnected();
+    });
+    this.socket.addEventListener("close", function () {
+      self.onDisconnected();
+    });
+    this.socket.addEventListener("message", function (event) {
+      _classPrivateMethodGet(self, _handleMessage, _handleMessage2).call(self, event.data);
+    });
+    this.socket.addEventListener("error", function (err) {
+      self.onWarningMessage(ErrorCode.ERR_IO, err);
+    });
+  }
+  async sendPointer(x, y) {
+    await super.waitForConnection();
+    let claims = await _auth.Auth.getUserClaims();
+    let msg = Message.fromObject({
+      pointer: {
+        email: claims.email,
+        x: x,
+        y: y
+      }
+    });
+    let buf = Message.encode(msg).finish();
+    this.socket.send(buf);
+  }
+  async sendDrawing(_ref) {
+    let {
+      email,
+      data
+    } = _ref;
+    await super.waitForConnection();
+    let msg = Message.fromObject({
+      drawing: {
+        email: email,
+        data: data
+      }
+    });
+    _index.logger.debug("".concat(this.getName(), ".Drawing: "), Message.toObject(msg));
+    let buf = Message.encode(msg).finish();
+    this.socket.send(buf);
+  }
+}
+async function _handleMessage2(msg) {
+  try {
+    if (msg instanceof ArrayBuffer) {
+      let buffer = new Uint8Array(msg);
+      let event = Message.decode(buffer);
+      if (event !== null && event !== void 0 && event.update) this.notify('onMeetingUpdate', event.update);
+      if (event !== null && event !== void 0 && event.drawing) this.notify('onDrawing', event.drawing);
+      if (event !== null && event !== void 0 && event.pointer) this.notify('onPointer', event);else if (event !== null && event !== void 0 && event.join) this.notify('onMeetingJoin', event.join);else if (event !== null && event !== void 0 && event.leave) this.notify('onMeetingLeave', event.leave);
+      return;
+    }
+  } catch (err) {
+    _index.logger.error(err);
+  }
+  try {
+    let Error = JSON.parse(msg);
+    switch (Error.code) {
+      case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+      case ErrorCode.ERR_UNAUTHORIZED:
+      case ErrorCode.ERR_BAD_REQUEST:
+      case ErrorCode.ERR_TIMEOUT:
+        this.onErrorMessage(Error.code, Error.reason);
+        break;
+      default:
+        this.onInfoMessage(Error.code, Error.reason);
+        break;
+    }
+  } catch (e) {
+    _index.logger.error(e);
+    this.onWarningMessage(ErrorCode.ERR_IO, msg);
+  }
+}
+let MeetingConnection = new MeetingConnectionImp();
+exports.MeetingConnection = MeetingConnection;

package/ws/observable_connection.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObservableConnection = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/esnext.aggregate-error.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/esnext.promise.any.js");
+var _index = require("../utils/logger/index.js");
+var _connection_base = require("./connection_base.js");
+class ObservableConnection extends _connection_base.ConnectionBase {
+  constructor(connectionName) {
+    super(connectionName);
+    this.observers = new Map();
+  }
+  subscribe(id, observer) {
+    this.observers.set(id, observer);
+  }
+  unsubscribeAll() {
+    this.observers = new Map();
+  }
+  unsubscribe(id) {
+    try {
+      this.observers.delete(id);
+    } catch (err) {
+      _index.logger.error(err);
+    }
+  }
+  notify(eventName) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    this.observers.forEach(o => {
+      try {
+        let fn = o[eventName];
+        if (fn !== undefined) fn(...args);
+      } catch (err) {
+        _index.logger.error("Error occured notifying event ".concat(eventName), err);
+      }
+    });
+  }
+  callSubscribers(functionName) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    let promises = [];
+    this.observers.forEach(o => {
+      try {
+        let fn = o[functionName];
+        if (fn !== undefined) {
+          let res = fn(...args);
+          promises.push(res);
+        }
+      } catch (error) {
+        _index.logger.error(error);
+      }
+    });
+    return Promise.any(promises);
+  }
+  onDisconnected() {
+    super.onDisconnected();
+    this.notify("onDisconnected");
+  }
+  onConnected() {
+    super.onConnected();
+    this.notify("onConnected");
+  }
+  onStopped() {
+    super.onStopped();
+    this.notify("onStopped");
+  }
+  onErrorMessage(code, reason) {
+    super.onErrorMessage(code, reason);
+    this.notify("onErrorMessage", code, reason);
+  }
+  onWarningMessage(code, reason) {
+    super.onWarningMessage(code, reason);
+    this.notify("onWarningMessage", code, reason);
+  }
+  onInfoMessage(code, reason) {
+    super.onInfoMessage(code, reason);
+    this.notify("onInfoMessage", code, reason);
+  }
+}
+exports.ObservableConnection = ObservableConnection;

package/ws/retry_connection.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RetryConnection = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+var _index = require("../utils/logger/index.js");
+var _observable_connection = require("./observable_connection.js");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+var _started = /*#__PURE__*/new WeakMap();
+var _reconnect = /*#__PURE__*/new WeakSet();
+class RetryConnection extends _observable_connection.ObservableConnection {
+  constructor(connectionName) {
+    let maxRetryCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;
+    let minRetryIntervalMs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 500;
+    let maxRetryIntervalMs = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 32000;
+    super(connectionName);
+    _classPrivateMethodInitSpec(this, _reconnect);
+    _classPrivateFieldInitSpec(this, _started, {
+      writable: true,
+      value: void 0
+    });
+    this.maxRetryCount = maxRetryCount;
+    this.minRetryIntervalMs = minRetryIntervalMs;
+    this.maxRetryIntervalMs = maxRetryIntervalMs;
+    this.retryCount = 0;
+    this.retryIntervalMs = minRetryIntervalMs;
+    this.lastConnectionTime = Date.now() - maxRetryIntervalMs;
+    this.retryTimer = null;
+    _classPrivateFieldSet(this, _started, false);
+  }
+  start() {
+    if (!this.isStarted()) {
+      _index.logger.info("".concat(this.getName(), ": starting..."));
+      _classPrivateFieldSet(this, _started, true);
+      this.connect();
+    }
+  }
+  stop() {
+    _index.logger.info("".concat(this.getName(), ": stopping..."));
+    _classPrivateFieldSet(this, _started, false);
+    this.disconnect();
+  }
+  isStarted() {
+    return _classPrivateFieldGet(this, _started);
+  }
+  onDisconnected() {
+    super.onDisconnected();
+    if (this.isStarted()) _classPrivateMethodGet(this, _reconnect, _reconnect2).call(this);
+  }
+  connect() {
+    if (this.isStarted()) super.connect();
+  }
+  disconnect() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    super.disconnect();
+  }
+  onErrorMessage(code, reason) {
+    super.onErrorMessage(code, reason);
+    this.stop();
+  }
+}
+exports.RetryConnection = RetryConnection;
+function _reconnect2() {
+  let self = this;
+  if (Date.now() - this.lastConnectionTime < this.retryIntervalMs) {
+    this.retryIntervalMs = Math.min(this.retryIntervalMs * 2, this.maxRetryIntervalMs);
+    this.retryCount = this.retryCount + 1;
+  } else {
+    this.retryCount = 1;
+    this.retryIntervalMs = this.minRetryIntervalMs;
+  }
+  if (this.retryCount >= this.maxRetryCount) {
+    this.stop();
+    return;
+  }
+  this.retryTimer = setTimeout(() => {
+    _index.logger.info("".concat(this.getName(), ": retrying connection... [interval: ").concat(this.retryIntervalMs, "ms]"));
+    self.lastConnectionTime = Date.now() + 4000;
+    self.connect();
+  }, this.retryIntervalMs);
+}

package/.babelrc

@@ -1,31 +0,0 @@
-{
-  "env": {
-    "webapp": {
-			"ignore": ["**/*.xapi.js", "**/*.webex-devices.js"],
-			"presets": [
-				[
-					"@babel/env",
-					{
-						"targets": {
-							"edge": "17",
-							"firefox": "60",
-							"chrome": "67",
-							"safari": "11.1"
-						},
-						"useBuiltIns": "usage",
-						"corejs": "3.6.5"
-					}
-				]
-			],
-
-			"plugins": [
-				[
-					"babel-plugin-transform-import-ignore",
-					{
-						"patterns": [".webex-devices.js", "*xapi*"]
-					}
-				]
-			]
-		}
-  }
-}

package/README.md

@@ -1,4 +0,0 @@
-# jibb-jssdk
-For SDK Documentation please visit: http://inkerz.github.io/jibb-jssdk
-
-also, please see code examples under Namespaces > Examples