@jibb-open/jssdk 3.5.8 → 3.5.9

package/dist/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/dist/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/dist/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jibb-open/jssdk",
-	"version": "3.5.8",
+	"version": "3.5.9",
 	"description": "",
 	"scripts": {
 		"test": "LOG_LEVEL=error mocha --timeout 10000 ",