@agilemotion/oui-react-js 1.6.1 → 1.6.2

package/dist/components/media/MediaSoupHelper.js

@@ -15,209 +15,401 @@ var _VCEventManager = _interopRequireDefault(require("./VCEventManager"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-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; }
-
-class MediaSoupHelper {
-  constructor() {
-    _defineProperty(this, "getParticipantDevice", async routerRtpCapabilities => {
-      let device;
-
-      try {
-        device = new _mediasoupClient.Device();
-      } catch (error) {
-        console.error(error);
-      }
-
-      await device.load({
-        routerRtpCapabilities
-      });
-      return device;
-    });
-
-    _defineProperty(this, "getConsumeStream", async (producerId, rtpCapabilities, consumerTransport, roomId, userId, type) => {
-      console.log("CONSUMING FROM : " + producerId);
-
-      if (consumerTransport) {
-        const data = await _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONSUME, {
-          rtpCapabilities,
-          consumerTransportId: consumerTransport.id,
-          producerId,
-          roomId,
-          userId,
-          kind: type
-        });
-
-        if (data.params) {
-          const {
-            id,
-            kind,
-            rtpParameters
-          } = data.params;
-          let codecOptions = {};
-
-          try {
-            const consumer = await consumerTransport.consume({
-              id,
-              producerId,
-              kind,
-              rtpParameters,
-              codecOptions
-            });
-            console.log(consumer);
-            const stream = new MediaStream();
-            stream.addTrack(consumer.track);
-            return {
-              consumer,
-              stream,
-              kind
-            };
-          } catch (e) {
-            console.error(e);
-          }
-        }
-      }
-
-      return {};
-    });
-  }
-
-  async initConsumerTransport(device, roomId, userId) {
-    console.log("CREATING CONSUMER TRANSPORT FOR : " + userId);
-    let data = null;
-
-    try {
-      data = await _SocketManager.default.emitEvent(_VCEventType.VCEventType.CREATE_WEBRTC_TRANSPORT, {
-        forceTcp: false,
-        userId,
-        roomId
-      });
-    } catch (e) {
-      _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
-    }
-
-    if (!data || data.status === 'ERROR') {
-      if (data) {
-        console.error(data.error);
-      }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-      _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-      return;
-    }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-    let consumerTransport = device.createRecvTransport(data.params);
-    consumerTransport.on('connect', function ({
-      dtlsParameters
-    }, callback, errback) {
-      console.log("CONSUMER CONNECT DTLS PARAMS : ", dtlsParameters);
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-      _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONNECT_TRANSPORT, {
-        dtlsParameters,
-        transportId: data.params.id,
-        userId,
-        roomId
-      }).then(callback).catch(errback);
-    }.bind(this));
-    consumerTransport.on('connectionstatechange', async function (state) {
-      switch (state) {
-        case 'connecting':
-          break;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-        case 'connected':
-          break;
-
-        case 'failed':
-          _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CONSUMER_TRANSPORT_FAILED, {});
+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; }
 
-          break;
+var MediaSoupHelper = /*#__PURE__*/function () {
+  function MediaSoupHelper() {
+    _classCallCheck(this, MediaSoupHelper);
+
+    _defineProperty(this, "getParticipantDevice", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(routerRtpCapabilities) {
+        var device;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                try {
+                  device = new _mediasoupClient.Device();
+                } catch (error) {
+                  console.error(error);
+                }
+
+                _context.next = 3;
+                return device.load({
+                  routerRtpCapabilities: routerRtpCapabilities
+                });
+
+              case 3:
+                return _context.abrupt("return", device);
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+
+    _defineProperty(this, "getConsumeStream", /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(producerId, rtpCapabilities, consumerTransport, roomId, userId, type) {
+        var data, _data$params, id, kind, rtpParameters, codecOptions, consumer, stream;
+
+        return regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                console.log("CONSUMING FROM : " + producerId);
+
+                if (!consumerTransport) {
+                  _context2.next = 21;
+                  break;
+                }
+
+                _context2.next = 4;
+                return _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONSUME, {
+                  rtpCapabilities: rtpCapabilities,
+                  consumerTransportId: consumerTransport.id,
+                  producerId: producerId,
+                  roomId: roomId,
+                  userId: userId,
+                  kind: type
+                });
+
+              case 4:
+                data = _context2.sent;
+
+                if (!data.params) {
+                  _context2.next = 21;
+                  break;
+                }
+
+                _data$params = data.params, id = _data$params.id, kind = _data$params.kind, rtpParameters = _data$params.rtpParameters;
+                codecOptions = {};
+                _context2.prev = 8;
+                _context2.next = 11;
+                return consumerTransport.consume({
+                  id: id,
+                  producerId: producerId,
+                  kind: kind,
+                  rtpParameters: rtpParameters,
+                  codecOptions: codecOptions
+                });
+
+              case 11:
+                consumer = _context2.sent;
+                console.log(consumer);
+                stream = new MediaStream();
+                stream.addTrack(consumer.track);
+                return _context2.abrupt("return", {
+                  consumer: consumer,
+                  stream: stream,
+                  kind: kind
+                });
+
+              case 18:
+                _context2.prev = 18;
+                _context2.t0 = _context2["catch"](8);
+                console.error(_context2.t0);
+
+              case 21:
+                return _context2.abrupt("return", {});
+
+              case 22:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, null, [[8, 18]]);
+      }));
 
-        default:
-          break;
-      }
-    }.bind(this));
-    return consumerTransport;
+      return function (_x2, _x3, _x4, _x5, _x6, _x7) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
   }
 
-  async initProducerTransport(device, roomId, userId) {
-    let data = null;
-
-    try {
-      data = await _SocketManager.default.emitEvent(_VCEventType.VCEventType.CREATE_WEBRTC_TRANSPORT, {
-        forceTcp: false,
-        rtpCapabilities: device.rtpCapabilities,
-        roomId,
-        userId
-      });
-    } catch (e) {
-      _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
-    }
-
-    if (!data || data.status === 'ERROR') {
-      if (data) {
-        console.error(data.error);
-      }
+  _createClass(MediaSoupHelper, [{
+    key: "initConsumerTransport",
+    value: function () {
+      var _initConsumerTransport = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(device, roomId, userId) {
+        var data, consumerTransport;
+        return regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                console.log("CREATING CONSUMER TRANSPORT FOR : " + userId);
+                data = null;
+                _context4.prev = 2;
+                _context4.next = 5;
+                return _SocketManager.default.emitEvent(_VCEventType.VCEventType.CREATE_WEBRTC_TRANSPORT, {
+                  forceTcp: false,
+                  userId: userId,
+                  roomId: roomId
+                });
+
+              case 5:
+                data = _context4.sent;
+                _context4.next = 11;
+                break;
+
+              case 8:
+                _context4.prev = 8;
+                _context4.t0 = _context4["catch"](2);
+
+                _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
+
+              case 11:
+                if (!(!data || data.status === 'ERROR')) {
+                  _context4.next = 15;
+                  break;
+                }
+
+                if (data) {
+                  console.error(data.error);
+                }
+
+                _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
+
+                return _context4.abrupt("return");
+
+              case 15:
+                consumerTransport = device.createRecvTransport(data.params);
+                consumerTransport.on('connect', function (_ref3, callback, errback) {
+                  var dtlsParameters = _ref3.dtlsParameters;
+                  console.log("CONSUMER CONNECT DTLS PARAMS : ", dtlsParameters);
+
+                  _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONNECT_TRANSPORT, {
+                    dtlsParameters: dtlsParameters,
+                    transportId: data.params.id,
+                    userId: userId,
+                    roomId: roomId
+                  }).then(callback).catch(errback);
+                }.bind(this));
+                consumerTransport.on('connectionstatechange', /*#__PURE__*/function () {
+                  var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(state) {
+                    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            _context3.t0 = state;
+                            _context3.next = _context3.t0 === 'connecting' ? 3 : _context3.t0 === 'connected' ? 4 : _context3.t0 === 'failed' ? 5 : 7;
+                            break;
+
+                          case 3:
+                            return _context3.abrupt("break", 8);
+
+                          case 4:
+                            return _context3.abrupt("break", 8);
+
+                          case 5:
+                            _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CONSUMER_TRANSPORT_FAILED, {});
+
+                            return _context3.abrupt("break", 8);
+
+                          case 7:
+                            return _context3.abrupt("break", 8);
+
+                          case 8:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+
+                  return function (_x11) {
+                    return _ref4.apply(this, arguments);
+                  };
+                }().bind(this));
+                return _context4.abrupt("return", consumerTransport);
+
+              case 19:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this, [[2, 8]]);
+      }));
 
-      _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
-
-      return;
-    }
-
-    let producerTransport = device.createSendTransport(data.params);
-    producerTransport.on('connect', async function ({
-      dtlsParameters
-    }, callback, errback) {
-      _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONNECT_TRANSPORT, {
-        dtlsParameters,
-        transportId: data.params.id,
-        roomId,
-        userId
-      }).then(callback).catch(errback);
-    }.bind(this));
-    producerTransport.on('produce', async function ({
-      kind,
-      rtpParameters,
-      appData
-    }, callback, errback) {
-      try {
-        const {
-          producerId
-        } = await _SocketManager.default.emitEvent(_VCEventType.VCEventType.PRODUCE, {
-          producerTransportId: producerTransport.id,
-          kind,
-          rtpParameters,
-          roomId,
-          userId,
-          appData
-        });
-        callback({
-          id: producerId
-        });
-      } catch (err) {
-        errback(err);
+      function initConsumerTransport(_x8, _x9, _x10) {
+        return _initConsumerTransport.apply(this, arguments);
       }
-    }.bind(this));
-    producerTransport.on('connectionstatechange', function (state) {
-      switch (state) {
-        case 'connecting':
-          break;
-
-        case 'connected':
-          break;
 
-        case 'failed':
-          producerTransport.close();
-          break;
+      return initConsumerTransport;
+    }()
+  }, {
+    key: "initProducerTransport",
+    value: function () {
+      var _initProducerTransport = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(device, roomId, userId) {
+        var data, producerTransport;
+        return regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                data = null;
+                _context7.prev = 1;
+                _context7.next = 4;
+                return _SocketManager.default.emitEvent(_VCEventType.VCEventType.CREATE_WEBRTC_TRANSPORT, {
+                  forceTcp: false,
+                  rtpCapabilities: device.rtpCapabilities,
+                  roomId: roomId,
+                  userId: userId
+                });
+
+              case 4:
+                data = _context7.sent;
+                _context7.next = 10;
+                break;
+
+              case 7:
+                _context7.prev = 7;
+                _context7.t0 = _context7["catch"](1);
+
+                _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
+
+              case 10:
+                if (!(!data || data.status === 'ERROR')) {
+                  _context7.next = 14;
+                  break;
+                }
+
+                if (data) {
+                  console.error(data.error);
+                }
+
+                _VCEventManager.default.fireEvent(_VCEventType.VCEventType.CREATE_TRANSPORT_FAILED, {});
+
+                return _context7.abrupt("return");
+
+              case 14:
+                producerTransport = device.createSendTransport(data.params);
+                producerTransport.on('connect', /*#__PURE__*/function () {
+                  var _ref6 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(_ref5, callback, errback) {
+                    var dtlsParameters;
+                    return regeneratorRuntime.wrap(function _callee5$(_context5) {
+                      while (1) {
+                        switch (_context5.prev = _context5.next) {
+                          case 0:
+                            dtlsParameters = _ref5.dtlsParameters;
+
+                            _SocketManager.default.emitEvent(_VCEventType.VCEventType.CONNECT_TRANSPORT, {
+                              dtlsParameters: dtlsParameters,
+                              transportId: data.params.id,
+                              roomId: roomId,
+                              userId: userId
+                            }).then(callback).catch(errback);
+
+                          case 2:
+                          case "end":
+                            return _context5.stop();
+                        }
+                      }
+                    }, _callee5);
+                  }));
+
+                  return function (_x15, _x16, _x17) {
+                    return _ref6.apply(this, arguments);
+                  };
+                }().bind(this));
+                producerTransport.on('produce', /*#__PURE__*/function () {
+                  var _ref8 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee6(_ref7, callback, errback) {
+                    var kind, rtpParameters, appData, _yield$socketManager$, producerId;
+
+                    return regeneratorRuntime.wrap(function _callee6$(_context6) {
+                      while (1) {
+                        switch (_context6.prev = _context6.next) {
+                          case 0:
+                            kind = _ref7.kind, rtpParameters = _ref7.rtpParameters, appData = _ref7.appData;
+                            _context6.prev = 1;
+                            _context6.next = 4;
+                            return _SocketManager.default.emitEvent(_VCEventType.VCEventType.PRODUCE, {
+                              producerTransportId: producerTransport.id,
+                              kind: kind,
+                              rtpParameters: rtpParameters,
+                              roomId: roomId,
+                              userId: userId,
+                              appData: appData
+                            });
+
+                          case 4:
+                            _yield$socketManager$ = _context6.sent;
+                            producerId = _yield$socketManager$.producerId;
+                            callback({
+                              id: producerId
+                            });
+                            _context6.next = 12;
+                            break;
+
+                          case 9:
+                            _context6.prev = 9;
+                            _context6.t0 = _context6["catch"](1);
+                            errback(_context6.t0);
+
+                          case 12:
+                          case "end":
+                            return _context6.stop();
+                        }
+                      }
+                    }, _callee6, null, [[1, 9]]);
+                  }));
+
+                  return function (_x18, _x19, _x20) {
+                    return _ref8.apply(this, arguments);
+                  };
+                }().bind(this));
+                producerTransport.on('connectionstatechange', function (state) {
+                  switch (state) {
+                    case 'connecting':
+                      break;
+
+                    case 'connected':
+                      break;
+
+                    case 'failed':
+                      producerTransport.close();
+                      break;
+
+                    default:
+                      break;
+                  }
+                }.bind(this));
+                return _context7.abrupt("return", producerTransport);
+
+              case 19:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this, [[1, 7]]);
+      }));
 
-        default:
-          break;
+      function initProducerTransport(_x12, _x13, _x14) {
+        return _initProducerTransport.apply(this, arguments);
       }
-    }.bind(this));
-    return producerTransport;
-  }
 
-}
+      return initProducerTransport;
+    }()
+  }]);
+
+  return MediaSoupHelper;
+}();
 
-const instance = new MediaSoupHelper();
+var instance = new MediaSoupHelper();
 Object.freeze(instance);
 var _default = instance;
 exports.default = _default;

package/dist/components/media/SideBarContent.js

@@ -14,27 +14,35 @@ var _VCParticipantList = _interopRequireDefault(require("./VCParticipantList"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 //import ChatRoom from '../chat/ChatRoom';
-const SideBarContent = props => {
-  const {
-    tab,
-    isHost,
-    meetingId,
-    participants,
-    meetingChat
-  } = props;
+var SideBarContent = function SideBarContent(props) {
+  var tab = props.tab,
+      isHost = props.isHost,
+      meetingId = props.meetingId,
+      participants = props.participants,
+      meetingChat = props.meetingChat;
 
-  _react.default.useEffect(() => {}, [meetingChat]);
+  _react.default.useEffect(function () {}, [meetingChat]);
 
   return /*#__PURE__*/_react.default.createElement("div", {
     className: 'meeting-room-sb-container'
   }, /*#__PURE__*/_react.default.createElement("div", {
     className: 'list'
   }, tab === 'People' ? /*#__PURE__*/_react.default.createElement(_VCParticipantList.default, {
-    onChangeMeetingHostHandler: e => props.onChangeMeetingHostHandler(e),
-    onPinHandler: (participant, pinned) => props.onPinHandler(participant, pinned),
-    onBringToViewHandler: participant => props.onBringToViewHandler(participant),
-    onHostVideoMute: participant => props.onHostVideoMute(participant),
-    onHostAudioMute: participant => props.onHostAudioMute(participant),
+    onChangeMeetingHostHandler: function onChangeMeetingHostHandler(e) {
+      return props.onChangeMeetingHostHandler(e);
+    },
+    onPinHandler: function onPinHandler(participant, pinned) {
+      return props.onPinHandler(participant, pinned);
+    },
+    onBringToViewHandler: function onBringToViewHandler(participant) {
+      return props.onBringToViewHandler(participant);
+    },
+    onHostVideoMute: function onHostVideoMute(participant) {
+      return props.onHostVideoMute(participant);
+    },
+    onHostAudioMute: function onHostAudioMute(participant) {
+      return props.onHostAudioMute(participant);
+    },
     isHost: isHost,
     participants: participants
   }) : null

package/dist/components/media/SocketRequest.js

@@ -5,9 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
 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; }
 
-class SocketRequest {}
+var SocketRequest = function SocketRequest() {
+  _classCallCheck(this, SocketRequest);
+};
 
 exports.default = SocketRequest;
 

package/dist/components/media/SocketResponse.js

@@ -5,9 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
 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; }
 
-class SocketResponse {}
+var SocketResponse = function SocketResponse() {
+  _classCallCheck(this, SocketResponse);
+};
 
 exports.default = SocketResponse;