@jibb-open/jssdk 3.5.8 → 3.5.10

package/utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("./logger.js");
+var _default = {
+  logger: _logger.logger
+};
+exports.default = _default;

package/utils/logger/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = exports.initPinoLogger = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _loggerEmpty = require("./logger.empty.js");
+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 logger = _loggerEmpty.logger;
+exports.logger = logger;
+const initPinoLogger = () => {
+  Promise.resolve().then(() => _interopRequireWildcard(require("./logger.pino.js"))).then(_exports => {
+    exports.logger = logger = _exports.logger;
+  });
+};
+exports.initPinoLogger = initPinoLogger;

package/utils/logger/logger.empty.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+class EmptyLoggerr {
+  error() {
+    // This is intentional
+  }
+  debug() {
+    // This is intentional
+  }
+  warn() {
+    // This is intentional
+  }
+  info() {
+    // This is intentional
+  }
+  setLevel() {
+    // This is intentional
+  }
+}
+let logger = new EmptyLoggerr();
+exports.logger = logger;

package/utils/logger/logger.pino.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _pino = _interopRequireDefault(require("pino"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let logger = new _pino.default({
+  browser: {
+    asObject: false
+  },
+  timestamp: false,
+  level: "warn"
+});
+exports.logger = logger;
+logger.setLevel = level => {
+  logger.level = level;
+};

package/ws/connection_base.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConnectionStatus = exports.ConnectionBase = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+var _index = require("../utils/logger/index.js");
+var _future = require("../utils/future.js");
+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 _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 ConnectionStatus = {
+  CONNECTED: "CONNECTED",
+  DISCONNECTED: "DISCONNECTED",
+  CONNECTING: "CONNECTING"
+};
+exports.ConnectionStatus = ConnectionStatus;
+var _name = /*#__PURE__*/new WeakMap();
+var _connectionStatus = /*#__PURE__*/new WeakMap();
+var _connectionFuture = /*#__PURE__*/new WeakMap();
+class ConnectionBase {
+  constructor(name) {
+    _classPrivateFieldInitSpec(this, _name, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _connectionStatus, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldInitSpec(this, _connectionFuture, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldSet(this, _name, name);
+    _classPrivateFieldSet(this, _connectionStatus, ConnectionStatus.DISCONNECTED);
+    _classPrivateFieldSet(this, _connectionFuture, new _future.Future());
+    _classPrivateFieldGet(this, _connectionFuture).reject("disconnected");
+  }
+  getName() {
+    return _classPrivateFieldGet(this, _name);
+  }
+  connect() {
+    switch (_classPrivateFieldGet(this, _connectionStatus)) {
+      case ConnectionStatus.CONNECTED:
+        _index.logger.error("".concat(this.getName(), ": already connected"));
+        break;
+      case ConnectionStatus.CONNECTING:
+        _index.logger.error("".concat(this.getName(), ": connection already in progress"));
+        break;
+      case ConnectionStatus.DISCONNECTED:
+        _index.logger.info("".concat(this.getName(), ": connecting ..."));
+        _classPrivateFieldSet(this, _connectionStatus, ConnectionStatus.CONNECTING);
+        _classPrivateFieldSet(this, _connectionFuture, new _future.Future());
+        break;
+    }
+  }
+  disconnect() {
+    this.onDisconnected();
+  }
+  onConnected() {
+    _index.logger.info("".concat(this.getName(), ": connected"));
+    _classPrivateFieldSet(this, _connectionStatus, ConnectionStatus.CONNECTED);
+    _classPrivateFieldGet(this, _connectionFuture).set("connected");
+  }
+  onDisconnected() {
+    _index.logger.warn("".concat(this.getName(), ": disconnected"));
+    _classPrivateFieldSet(this, _connectionStatus, ConnectionStatus.DISCONNECTED);
+    _classPrivateFieldGet(this, _connectionFuture).reject("disconnected");
+  }
+  isConnected() {
+    return _classPrivateFieldGet(this, _connectionStatus) == ConnectionStatus.CONNECTED;
+  }
+  waitForConnection() {
+    return _classPrivateFieldGet(this, _connectionFuture).get();
+  }
+  getConnectionStatus() {
+    return _classPrivateFieldGet(this, _connectionStatus);
+  }
+  onErrorMessage(code, reason) {
+    _index.logger.warn("".concat(this.getName(), ": onErrorMessage, code: ").concat(code, ", reason: ").concat(reason));
+  }
+  onWarningMessage(code, reason) {
+    _index.logger.warn("".concat(this.getName(), ": onWarningMessage, code: ").concat(code, ", reason: ").concat(reason));
+  }
+  onInfoMessage(code, reason) {
+    _index.logger.info("".concat(this.getName(), ": onInfoMessage, code: ").concat(code, ", reason: ").concat(reason));
+  }
+}
+exports.ConnectionBase = ConnectionBase;

package/ws/eventbus.js

@@ -0,0 +1,376 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventBusConnection = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.promise.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 _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _exceptions = require("../types/exceptions.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");
+var _auth = require("../api/auth.js");
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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; } }
+const ClientType = _proto.types.ClientType;
+const ErrorCode = _proto.types.Code;
+const BusMessage = _proto.cilix.BusMessage;
+function getClientNameByType(clientType) {
+  let found = Object.entries(ClientType).find(_ref => {
+    let [k, v] = _ref;
+    return v == clientType;
+  });
+  if (!found) throw new _exceptions.InvalidArgumentError("Invalid client type: ".concat(clientType));
+  let name = found[0].toLowerCase();
+  return name;
+}
+var _expiryTimer = /*#__PURE__*/new WeakMap();
+var _handleMessage = /*#__PURE__*/new WeakSet();
+class WSConnection extends _retry_connection.RetryConnection {
+  constructor(clientType, name) {
+    let clientName = getClientNameByType(clientType).toLowerCase();
+    super("eventbus-".concat(clientName));
+    _classPrivateMethodInitSpec(this, _handleMessage);
+    _classPrivateFieldInitSpec(this, _expiryTimer, {
+      writable: true,
+      value: void 0
+    });
+    this.clientType = clientType;
+    this.socket = null;
+    this.userToken = null;
+    this.clientName = clientName;
+    this.name = name;
+    _classPrivateFieldSet(this, _expiryTimer, null);
+  }
+  async start() {
+    this.userToken = await _auth.Auth.getUserToken();
+    this.userClaims = new _types.UserClaims(this.userToken);
+    let seconds = this.userClaims.getSecondsUntilExpiry();
+    if (seconds <= 0) {
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+      return;
+    }
+    _classPrivateFieldSet(this, _expiryTimer, setTimeout(() => {
+      this.stop();
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "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.WARNING, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+      _index.logger.info("eventbus disconnect ", this.clientName);
+    }
+    super.disconnect();
+  }
+  async write(msg) {
+    await super.waitForConnection();
+    _index.logger.debug("".concat(this.getName(), ".write: "), BusMessage.toObject(msg));
+    let data = BusMessage.encode(msg).finish();
+    this.socket.send(data);
+  }
+  writeObject(msg) {
+    let err = BusMessage.verify(msg);
+    if (err) throw new Error(err);
+    let request = BusMessage.fromObject(msg);
+    return this.write(request);
+  }
+  async connect() {
+    if (this.getConnectionStatus() != _connection_base.ConnectionStatus.DISCONNECTED) return;
+    super.connect();
+    let self = this;
+    try {
+      let c = new _types.UserClaims(this.userToken);
+      if (c.isExpired()) {
+        self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      }
+    } catch (err) {
+      _index.logger.error(e);
+      self.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+      return;
+    }
+    let base = new URL(_config.Config.apiBaseURL);
+    let uri = "wss://".concat(base.hostname, "/ws/eventbus/").concat(this.clientName, "?user_token=").concat(this.userToken, "&name=").concat(this.name);
+    this.socket = new WebSocket(uri);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", () => {
+      self.onConnected();
+    });
+    this.socket.addEventListener("close", () => {
+      self.onDisconnected();
+    });
+    this.socket.addEventListener("message", event => {
+      _classPrivateMethodGet(self, _handleMessage, _handleMessage2).call(self, event.data);
+    });
+    this.socket.addEventListener("error", err => {
+      self.onWarningMessage(ErrorCode.ERR_IO, err);
+    });
+  }
+  onMessage(response) {
+    _index.logger.debug(response);
+  }
+}
+async function _handleMessage2(msg) {
+  try {
+    if (msg instanceof ArrayBuffer) {
+      let buffer = new Uint8Array(msg);
+      let response = BusMessage.decode(buffer);
+      buffer = null;
+      _index.logger.debug("".concat(this.getName(), ".read: "), response);
+      this.onMessage(response);
+      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) {
+    this.onWarningMessage(ErrorCode.ERR_IO, e);
+  }
+}
+var _sendPreview = /*#__PURE__*/new WeakSet();
+var _onCameraListRequest = /*#__PURE__*/new WeakSet();
+var _onCameraListResponse = /*#__PURE__*/new WeakSet();
+var _onClientConnected = /*#__PURE__*/new WeakSet();
+var _onClientDisconnected = /*#__PURE__*/new WeakSet();
+var _onRuntimeConfigRequest = /*#__PURE__*/new WeakSet();
+var _onStopRequest = /*#__PURE__*/new WeakSet();
+var _onPreviewRequest = /*#__PURE__*/new WeakSet();
+var _onPreviewResponse = /*#__PURE__*/new WeakSet();
+var _onStartRequest = /*#__PURE__*/new WeakSet();
+var _onCornersReceived = /*#__PURE__*/new WeakSet();
+var _onIPSAResponse = /*#__PURE__*/new WeakSet();
+var _onTooManyPublishers = /*#__PURE__*/new WeakSet();
+var _onRecordingStarted = /*#__PURE__*/new WeakSet();
+var _onRecordingStopped = /*#__PURE__*/new WeakSet();
+class EventBusConnection extends WSConnection {
+  static getInstance() {
+    let clientType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ClientType.WEBAPP;
+    let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let c = EventBusConnection.instances.get(clientType);
+    if (!c) {
+      c = new EventBusConnection(clientType, name);
+      EventBusConnection.instances.set(clientType, c);
+    }
+    return c;
+  }
+  constructor() {
+    let clientType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ClientType.WEBAPP;
+    let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    super(clientType, name);
+    _classPrivateMethodInitSpec(this, _onRecordingStopped);
+    _classPrivateMethodInitSpec(this, _onRecordingStarted);
+    _classPrivateMethodInitSpec(this, _onTooManyPublishers);
+    _classPrivateMethodInitSpec(this, _onIPSAResponse);
+    _classPrivateMethodInitSpec(this, _onCornersReceived);
+    _classPrivateMethodInitSpec(this, _onStartRequest);
+    _classPrivateMethodInitSpec(this, _onPreviewResponse);
+    _classPrivateMethodInitSpec(this, _onPreviewRequest);
+    _classPrivateMethodInitSpec(this, _onStopRequest);
+    _classPrivateMethodInitSpec(this, _onRuntimeConfigRequest);
+    _classPrivateMethodInitSpec(this, _onClientDisconnected);
+    _classPrivateMethodInitSpec(this, _onClientConnected);
+    _classPrivateMethodInitSpec(this, _onCameraListResponse);
+    _classPrivateMethodInitSpec(this, _onCameraListRequest);
+    _classPrivateMethodInitSpec(this, _sendPreview);
+  }
+  async onMessage(msg) {
+    if (!msg || typeof msg !== 'object') return;
+    try {
+      msg.clientConnected && _classPrivateMethodGet(this, _onClientConnected, _onClientConnected2).call(this, msg);
+      msg.clientDisconnected && _classPrivateMethodGet(this, _onClientDisconnected, _onClientDisconnected2).call(this, msg);
+      msg.cameraListRequest && _classPrivateMethodGet(this, _onCameraListRequest, _onCameraListRequest2).call(this, msg);
+      msg.cameraListResponse && _classPrivateMethodGet(this, _onCameraListResponse, _onCameraListResponse2).call(this, msg);
+      msg.runtimeConfigRequest && _classPrivateMethodGet(this, _onRuntimeConfigRequest, _onRuntimeConfigRequest2).call(this, msg);
+      msg.startRequest && _classPrivateMethodGet(this, _onStartRequest, _onStartRequest2).call(this, msg);
+      msg.stopRequest && _classPrivateMethodGet(this, _onStopRequest, _onStopRequest2).call(this, msg);
+      msg.previewRequest && _classPrivateMethodGet(this, _onPreviewRequest, _onPreviewRequest2).call(this, msg);
+      msg.previewResponse && _classPrivateMethodGet(this, _onPreviewResponse, _onPreviewResponse2).call(this, msg);
+      msg.ipsaResponse && _classPrivateMethodGet(this, _onIPSAResponse, _onIPSAResponse2).call(this, msg);
+      msg.tooManyPublishers && _classPrivateMethodGet(this, _onTooManyPublishers, _onTooManyPublishers2).call(this, msg);
+      msg.recordingStarted && _classPrivateMethodGet(this, _onRecordingStarted, _onRecordingStarted2).call(this, msg);
+      msg.recordingStopped && _classPrivateMethodGet(this, _onRecordingStopped, _onRecordingStopped2).call(this, msg);
+    } catch (e) {
+      _index.logger.error(e);
+    }
+  }
+  stopStream(clientId) {
+    return this.writeObject({
+      stopRequest: {},
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  startStream(_ref2) {
+    let {
+      appConfig,
+      config,
+      runtimeConfig,
+      camera,
+      sipUri,
+      clientId
+    } = _ref2;
+    return this.writeObject({
+      startRequest: {
+        config,
+        appConfig,
+        runtimeConfig,
+        camera,
+        sipUri
+      },
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  requestCameraPreview(clientId, sourceId) {
+    return this.writeObject({
+      previewRequest: {
+        source: {
+          id: sourceId
+        }
+      },
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  setRuntimeConfig(clientId, cfg) {
+    return this.writeObject({
+      runtimeConfigRequest: cfg,
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  getCameraList(clientId) {
+    let request = {
+      cameraListRequest: {},
+      dst: {
+        id: clientId
+      }
+    };
+    return this.write(request);
+  }
+  sendCameraList(camList, src, dst) {
+    let response = {
+      cameraListResponse: {
+        items: camList
+      },
+      src: src,
+      dst: dst
+    };
+    return this.writeObject(response);
+  }
+  getClientStatusList() {
+    let request = {
+      clientStatusRequest: {}
+    };
+    return this.writeObject(request);
+  }
+}
+exports.EventBusConnection = EventBusConnection;
+function _sendPreview2(image, dst) {
+  let response = {
+    previewResponse: {
+      image: image
+    },
+    dst: dst
+  };
+  return this.write(response);
+}
+async function _onCameraListRequest2(msg) {
+  let response = await this.callSubscribers('onCameraListRequest', msg.cameraListRequest);
+  this.sendCameraList(response, msg.dst, msg.src);
+}
+function _onCameraListResponse2(msg) {
+  this.notify('onCameraListResponse', msg.cameraListResponse);
+}
+function _onClientConnected2(msg) {
+  _index.logger.info("".concat(this.getName(), ": client connected: "), msg.src);
+  this.notify('onClientConnected', msg.src);
+}
+function _onClientDisconnected2(msg) {
+  _index.logger.warn("".concat(this.getName(), ": client disconnected: "), msg.src);
+  this.notify('onClientDisconnected', msg.src);
+}
+function _onRuntimeConfigRequest2(msg) {
+  this.notify('onRuntimeConfigRequest', msg.runtimeConfigRequest);
+}
+function _onStopRequest2(msg) {
+  this.notify('onStopRequest', msg.stopRequest);
+}
+async function _onPreviewRequest2(msg) {
+  let response = await this.callSubscribers('onPreviewRequest', msg.previewRequest);
+  _classPrivateMethodGet(this, _sendPreview, _sendPreview2).call(this, response, msg.src);
+}
+function _onPreviewResponse2(msg) {
+  this.notify('onPreviewResponse', msg.previewResponse);
+}
+function _onStartRequest2(msg) {
+  var _req$camera, _req$inputSource;
+  let req = msg.startRequest;
+  if (!(req !== null && req !== void 0 && (_req$camera = req.camera) !== null && _req$camera !== void 0 && _req$camera.id) && !(req !== null && req !== void 0 && req.sipUri) && req !== null && req !== void 0 && (_req$inputSource = req.inputSource) !== null && _req$inputSource !== void 0 && _req$inputSource.id) {
+    req.camera = {
+      id: req.inputSource.id
+    };
+  }
+  this.notify('onStartRequest', req);
+}
+function _onCornersReceived2(msg) {
+  this.notify('onCornersReceived', msg.corners.corners);
+}
+function _onIPSAResponse2(msg) {
+  msg && this.notify('onIPSAResponse', msg.ipsaResponse);
+}
+function _onTooManyPublishers2(msg) {
+  this.notify('onTooManyPublishers', msg.tooManyPublishers);
+}
+function _onRecordingStarted2(msg) {
+  this.notify('onRecordingStarted', msg.recordingStarted);
+}
+function _onRecordingStopped2(msg) {
+  this.notify('onRecordingStopped', msg.recordingStopped);
+}
+_defineProperty(EventBusConnection, "instances", new Map());

package/ws/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.iterator.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "EventBusConnection", {
+  enumerable: true,
+  get: function get() {
+    return _eventbus.EventBusConnection;
+  }
+});
+Object.defineProperty(exports, "IPSA", {
+  enumerable: true,
+  get: function get() {
+    return _ipsa.IPSA;
+  }
+});
+Object.defineProperty(exports, "MeetingConnection", {
+  enumerable: true,
+  get: function get() {
+    return _meeting.MeetingConnection;
+  }
+});
+require("core-js/modules/es.global-this.js");
+require("core-js/modules/es.promise.js");
+var _eventbus = require("./eventbus.js");
+var _ipsa = require("./ipsa.js");
+var _meeting = require("./meeting.js");
+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; }
+if ((globalThis === null || globalThis === void 0 ? void 0 : globalThis.WebSocket) == undefined) {
+  Promise.resolve().then(() => _interopRequireWildcard(require("isomorphic-ws"))).then(webSocket => {
+    globalThis.WebSocket = webSocket.default;
+  });
+}