@atlaskit/collab-provider 8.4.0 → 8.5.0

package/dist/esm/errors/error-code-mapper.js

@@ -1,79 +1,102 @@
-import _typeof from "@babel/runtime/helpers/typeof";
-export var ErrorCodeMapper = {
-  noPermissionError: {
-    code: 'NO_PERMISSION_ERROR',
-    message: 'User does not have permissions to access this document or document is not found'
-  },
-  documentNotFound: {
-    code: 'DOCUMENT_NOT_FOUND',
-    message: 'The requested document is not found'
-  },
-  hasToLogin: {
-    code: 'HAS_TO_LOGIN',
-    message: 'The user needs to login'
-  },
-  catchupFail: {
-    code: 'CATCHUP_FAILED',
-    message: 'Cannot fetch catchup from collab service'
-  },
-  serviceUnvailable: {
-    code: 'SERVICE_UNAVAILABLE',
-    message: 'Service is not available'
-  },
-  failToSave: {
-    code: 'FAIL_TO_SAVE',
-    message: 'Collab service is not able to save changes'
-  },
-  restoreError: {
-    code: 'DOCUMENT_RESTORE_ERROR',
-    message: 'Collab service unable to restore document'
-  },
-  internalError: {
-    code: 'INTERNAL_SERVICE_ERROR',
-    message: 'Collab service has experienced an internal server error'
-  }
-};
+import { NCS_ERROR_CODE } from './error-types';
+import { INTERNAL_ERROR_CODE, PROVIDER_ERROR_CODE } from './error-types';
+
+/*
+ * Maps internal collab provider errors to an emitted error format
+ */
 export var errorCodeMapper = function errorCodeMapper(error) {
-  var _error$data;
+  var _error$data, _error$data2, _error$data3;
   switch ((_error$data = error.data) === null || _error$data === void 0 ? void 0 : _error$data.code) {
-    case 'INSUFFICIENT_EDITING_PERMISSION':
+    case NCS_ERROR_CODE.HEAD_VERSION_UPDATE_FAILED:
+    case NCS_ERROR_CODE.VERSION_NUMBER_ALREADY_EXISTS:
+      // This should never be called with these errors
+      return;
+    case INTERNAL_ERROR_CODE.ADD_STEPS_ERROR:
+    case INTERNAL_ERROR_CODE.RECONNECTION_ERROR:
+    case INTERNAL_ERROR_CODE.CONNECTION_ERROR:
+      // These errors shouldn't be emitted, we're hoping the provider self-recovers over time
+      return;
+    case NCS_ERROR_CODE.INSUFFICIENT_EDITING_PERMISSION:
+    case INTERNAL_ERROR_CODE.TOKEN_PERMISSION_ERROR:
+      return {
+        code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR,
+        message: 'User does not have permissions to access this document or document is not found',
+        reason: error.data.meta.reason,
+        recoverable: true,
+        status: 403
+      };
+    case NCS_ERROR_CODE.FORBIDDEN_USER_TOKEN:
+      return {
+        code: PROVIDER_ERROR_CODE.INVALID_USER_TOKEN,
+        message: 'The user token was invalid',
+        recoverable: true,
+        status: 403
+      };
+    case INTERNAL_ERROR_CODE.DOCUMENT_NOT_FOUND:
+      return {
+        code: PROVIDER_ERROR_CODE.DOCUMENT_NOT_FOUND,
+        message: 'The requested document is not found',
+        recoverable: true,
+        status: 404
+      };
+    case NCS_ERROR_CODE.TENANT_INSTANCE_MAINTENANCE:
+    case NCS_ERROR_CODE.LOCKED_DOCUMENT:
+      return {
+        code: PROVIDER_ERROR_CODE.LOCKED,
+        message: 'The document is currently not available, please try again later',
+        recoverable: true
+      };
+    case NCS_ERROR_CODE.DYNAMO_ERROR:
+      return {
+        code: PROVIDER_ERROR_CODE.FAIL_TO_SAVE,
+        message: 'Collab service is not able to save changes',
+        recoverable: false,
+        status: 500
+      };
+    case INTERNAL_ERROR_CODE.DOCUMENT_RESTORE_ERROR:
       return {
-        status: 403,
-        code: ErrorCodeMapper.noPermissionError.code,
-        message: ErrorCodeMapper.noPermissionError.message,
-        reason:
-        // Typescript magic so it detects the union type
-        _typeof(error.data.meta) === 'object' ? error.data.meta.reason : undefined
+        code: PROVIDER_ERROR_CODE.DOCUMENT_RESTORE_ERROR,
+        message: 'Collab service unable to restore document',
+        recoverable: false,
+        status: 500
       };
-    case 'DOCUMENT_NOT_FOUND':
+    case NCS_ERROR_CODE.INIT_DATA_LOAD_FAILED:
       return {
-        status: 404,
-        code: ErrorCodeMapper.documentNotFound.code,
-        message: ErrorCodeMapper.documentNotFound.message
+        code: PROVIDER_ERROR_CODE.INITIALISATION_ERROR,
+        message: "The initial document couldn't be loaded from the collab service",
+        recoverable: false,
+        status: 500
       };
-    case 'FAILED_ON_S3':
-    case 'DYNAMO_ERROR':
+    case INTERNAL_ERROR_CODE.RECONNECTION_NETWORK_ISSUE:
       return {
-        status: 500,
-        code: ErrorCodeMapper.failToSave.code,
-        message: ErrorCodeMapper.failToSave.message
+        code: PROVIDER_ERROR_CODE.NETWORK_ISSUE,
+        message: "Couldn't reconnect to the collab service due to network issues",
+        recoverable: true,
+        status: 500
       };
-    case 'DOCUMENT_RESTORE_ERROR':
+    case NCS_ERROR_CODE.NAMESPACE_INVALID:
+    case NCS_ERROR_CODE.INVALID_ACTIVATION_ID:
+    case NCS_ERROR_CODE.INVALID_DOCUMENT_ARI:
+    case NCS_ERROR_CODE.INVALID_CLOUD_ID:
       return {
-        status: 500,
-        code: ErrorCodeMapper.restoreError.code,
-        message: ErrorCodeMapper.restoreError.message
+        code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION,
+        message: 'Invalid provider configuration',
+        recoverable: false,
+        reason: (_error$data2 = error.data) === null || _error$data2 === void 0 ? void 0 : _error$data2.code,
+        status: 400
       };
-    // Temporarily re-added so we don't emit errors to Confluence by default as they will disconnect the collab provider
-    case 'CATCHUP_FAILED':
-    case 'GET_QUERY_TIME_OUT':
-    case 'INIT_DATA_LOAD_FAILED':
+    case NCS_ERROR_CODE.NAMESPACE_NOT_FOUND:
+    case NCS_ERROR_CODE.ERROR_MAPPING_ERROR:
+    case NCS_ERROR_CODE.EMPTY_BROADCAST:
+    case INTERNAL_ERROR_CODE.CATCHUP_FAILED:
       return {
-        status: 500,
-        code: ErrorCodeMapper.internalError.code,
-        message: ErrorCodeMapper.internalError.message
+        code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR,
+        message: 'Collab Provider experienced an unrecoverable error',
+        recoverable: false,
+        reason: (_error$data3 = error.data) === null || _error$data3 === void 0 ? void 0 : _error$data3.code,
+        status: 500
       };
     default:
-      break;
+      return;
   }
 };

package/dist/esm/errors/error-types.js

@@ -1,34 +1,259 @@
-import _createClass from "@babel/runtime/helpers/createClass";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
 import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-export var NotConnectedError = /*#__PURE__*/function (_Error) {
-  _inherits(NotConnectedError, _Error);
-  var _super = _createSuper(NotConnectedError);
-  function NotConnectedError(message) {
+// Internal error codes (generated by collab provider)
+export var INTERNAL_ERROR_CODE;
+// NCS error coded (generated by NCS)
+(function (INTERNAL_ERROR_CODE) {
+  INTERNAL_ERROR_CODE["TOKEN_PERMISSION_ERROR"] = "TOKEN_PERMISSION_ERROR";
+  INTERNAL_ERROR_CODE["RECONNECTION_NETWORK_ISSUE"] = "RECONNECTION_NETWORK_ISSUE";
+  INTERNAL_ERROR_CODE["CONNECTION_ERROR"] = "CONNECTION_ERROR";
+  INTERNAL_ERROR_CODE["RECONNECTION_ERROR"] = "RECONNECTION_ERROR";
+  INTERNAL_ERROR_CODE["DOCUMENT_NOT_FOUND"] = "DOCUMENT_NOT_FOUND";
+  INTERNAL_ERROR_CODE["CATCHUP_FAILED"] = "CATCHUP_FAILED";
+  INTERNAL_ERROR_CODE["DOCUMENT_RESTORE_ERROR"] = "DOCUMENT_RESTORE_ERROR";
+  INTERNAL_ERROR_CODE["ADD_STEPS_ERROR"] = "ADD_STEPS_ERROR";
+})(INTERNAL_ERROR_CODE || (INTERNAL_ERROR_CODE = {}));
+export var NCS_ERROR_CODE;
+
+// TODO: Import emitted error codes from NCS
+
+// NCS Errors
+// - Step rejection errors
+(function (NCS_ERROR_CODE) {
+  NCS_ERROR_CODE["HEAD_VERSION_UPDATE_FAILED"] = "HEAD_VERSION_UPDATE_FAILED";
+  NCS_ERROR_CODE["VERSION_NUMBER_ALREADY_EXISTS"] = "VERSION_NUMBER_ALREADY_EXISTS";
+  NCS_ERROR_CODE["INSUFFICIENT_EDITING_PERMISSION"] = "INSUFFICIENT_EDITING_PERMISSION";
+  NCS_ERROR_CODE["FORBIDDEN_USER_TOKEN"] = "FORBIDDEN_USER_TOKEN";
+  NCS_ERROR_CODE["DOCUMENT_NOT_FOUND"] = "DOCUMENT_NOT_FOUND";
+  NCS_ERROR_CODE["INIT_DATA_LOAD_FAILED"] = "INIT_DATA_LOAD_FAILED";
+  NCS_ERROR_CODE["ERROR_MAPPING_ERROR"] = "ERROR_MAPPING_ERROR";
+  NCS_ERROR_CODE["NAMESPACE_INVALID"] = "NAMESPACE_INVALID";
+  NCS_ERROR_CODE["NAMESPACE_NOT_FOUND"] = "NAMESPACE_NOT_FOUND";
+  NCS_ERROR_CODE["TENANT_INSTANCE_MAINTENANCE"] = "TENANT_INSTANCE_MAINTENANCE";
+  NCS_ERROR_CODE["LOCKED_DOCUMENT"] = "LOCKED_DOCUMENT";
+  NCS_ERROR_CODE["EMPTY_BROADCAST"] = "EMPTY_BROADCAST";
+  NCS_ERROR_CODE["DYNAMO_ERROR"] = "DYNAMO_ERROR";
+  NCS_ERROR_CODE["INVALID_ACTIVATION_ID"] = "INVALID_ACTIVATION_ID";
+  NCS_ERROR_CODE["INVALID_DOCUMENT_ARI"] = "INVALID_DOCUMENT_ARI";
+  NCS_ERROR_CODE["INVALID_CLOUD_ID"] = "INVALID_CLOUD_ID";
+})(NCS_ERROR_CODE || (NCS_ERROR_CODE = {}));
+// Emitted errors
+export var PROVIDER_ERROR_CODE;
+
+/*
+ * This is what a generic ProviderError type would look like:
+ * type ProviderError = {
+ *   // Unique code, identifies the specific emitted error
+ *   // Also exposed as a PROVIDER_ERROR_CODE enum to allow subscribers to use them
+ *   code: PROVIDER_ERROR_CODE;
+ *   // Informative message describing what went wrong
+ *   message: string;
+ *   // Flag indicating whether an error is recoverable or not
+ *   // used by consumers to disable the provider and show an error message
+ *   recoverable: boolean;
+ *   // A reason code used to give more detail about why a certain error was thrown
+ *   reason?: string;
+ * }
+ */
+
+/**
+ * This occurs when the provided user token is considered invalid for the given document ARI.
+ * It happens during initialisation of the provider.
+ * It could mean the document has been deleted (hence not found).
+ * @message Message returned to editor, i.e User does not have permissions to access this document or document is not found
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+(function (PROVIDER_ERROR_CODE) {
+  PROVIDER_ERROR_CODE["NO_PERMISSION_ERROR"] = "NO_PERMISSION_ERROR";
+  PROVIDER_ERROR_CODE["INVALID_USER_TOKEN"] = "INVALID_USER_TOKEN";
+  PROVIDER_ERROR_CODE["DOCUMENT_NOT_FOUND"] = "DOCUMENT_NOT_FOUND";
+  PROVIDER_ERROR_CODE["LOCKED"] = "LOCKED";
+  PROVIDER_ERROR_CODE["FAIL_TO_SAVE"] = "FAIL_TO_SAVE";
+  PROVIDER_ERROR_CODE["DOCUMENT_RESTORE_ERROR"] = "DOCUMENT_RESTORE_ERROR";
+  PROVIDER_ERROR_CODE["INITIALISATION_ERROR"] = "INITIALISATION_ERROR";
+  PROVIDER_ERROR_CODE["NETWORK_ISSUE"] = "NETWORK_ISSUE";
+  PROVIDER_ERROR_CODE["INVALID_PROVIDER_CONFIGURATION"] = "INVALID_PROVIDER_CONFIGURATION";
+  PROVIDER_ERROR_CODE["INTERNAL_SERVICE_ERROR"] = "INTERNAL_SERVICE_ERROR";
+})(PROVIDER_ERROR_CODE || (PROVIDER_ERROR_CODE = {}));
+// Custom Errors
+var CustomError = /*#__PURE__*/function (_Error) {
+  _inherits(CustomError, _Error);
+  var _super = _createSuper(CustomError);
+  function CustomError(message, error) {
     var _this;
-    _classCallCheck(this, NotConnectedError);
+    _classCallCheck(this, CustomError);
     _this = _super.call(this, message);
-    _defineProperty(_assertThisInitialized(_this), "name", 'NotConnectedError');
+    if (typeof (error === null || error === void 0 ? void 0 : error.message) === 'string') {
+      _this.message = error.message;
+    }
     return _this;
   }
-  return _createClass(NotConnectedError);
+  _createClass(CustomError, [{
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        name: this.name,
+        message: this.message
+      };
+    }
+  }]);
+  return CustomError;
 }( /*#__PURE__*/_wrapNativeSuper(Error));
-export var NotInitializedError = /*#__PURE__*/function (_Error2) {
-  _inherits(NotInitializedError, _Error2);
-  var _super2 = _createSuper(NotInitializedError);
-  function NotInitializedError(message) {
+export var NotConnectedError = /*#__PURE__*/function (_CustomError) {
+  _inherits(NotConnectedError, _CustomError);
+  var _super2 = _createSuper(NotConnectedError);
+  function NotConnectedError() {
     var _this2;
-    _classCallCheck(this, NotInitializedError);
-    _this2 = _super2.call(this, message);
-    _defineProperty(_assertThisInitialized(_this2), "name", 'NotInitializedError');
+    _classCallCheck(this, NotConnectedError);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this2 = _super2.call.apply(_super2, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this2), "name", 'NotConnectedError');
     return _this2;
   }
+  return _createClass(NotConnectedError);
+}(CustomError);
+export var NotInitializedError = /*#__PURE__*/function (_CustomError2) {
+  _inherits(NotInitializedError, _CustomError2);
+  var _super3 = _createSuper(NotInitializedError);
+  function NotInitializedError() {
+    var _this3;
+    _classCallCheck(this, NotInitializedError);
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    _this3 = _super3.call.apply(_super3, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this3), "name", 'NotInitializedError');
+    return _this3;
+  }
   return _createClass(NotInitializedError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
+}(CustomError);
+export var ProviderInitialisationError = /*#__PURE__*/function (_CustomError3) {
+  _inherits(ProviderInitialisationError, _CustomError3);
+  var _super4 = _createSuper(ProviderInitialisationError);
+  function ProviderInitialisationError() {
+    var _this4;
+    _classCallCheck(this, ProviderInitialisationError);
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    _this4 = _super4.call.apply(_super4, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this4), "name", 'ProviderInitialisationError');
+    return _this4;
+  }
+  return _createClass(ProviderInitialisationError);
+}(CustomError);
+export var SendTransactionError = /*#__PURE__*/function (_CustomError4) {
+  _inherits(SendTransactionError, _CustomError4);
+  var _super5 = _createSuper(SendTransactionError);
+  function SendTransactionError() {
+    var _this5;
+    _classCallCheck(this, SendTransactionError);
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    _this5 = _super5.call.apply(_super5, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this5), "name", 'SendTransactionError');
+    return _this5;
+  }
+  return _createClass(SendTransactionError);
+}(CustomError);
+export var DestroyError = /*#__PURE__*/function (_CustomError5) {
+  _inherits(DestroyError, _CustomError5);
+  var _super6 = _createSuper(DestroyError);
+  function DestroyError() {
+    var _this6;
+    _classCallCheck(this, DestroyError);
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    _this6 = _super6.call.apply(_super6, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this6), "name", 'DestroyError');
+    return _this6;
+  }
+  return _createClass(DestroyError);
+}(CustomError);
+export var SetTitleError = /*#__PURE__*/function (_CustomError6) {
+  _inherits(SetTitleError, _CustomError6);
+  var _super7 = _createSuper(SetTitleError);
+  function SetTitleError() {
+    var _this7;
+    _classCallCheck(this, SetTitleError);
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    _this7 = _super7.call.apply(_super7, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this7), "name", 'SetTitleError');
+    return _this7;
+  }
+  return _createClass(SetTitleError);
+}(CustomError);
+export var SetEditorWidthError = /*#__PURE__*/function (_CustomError7) {
+  _inherits(SetEditorWidthError, _CustomError7);
+  var _super8 = _createSuper(SetEditorWidthError);
+  function SetEditorWidthError() {
+    var _this8;
+    _classCallCheck(this, SetEditorWidthError);
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    _this8 = _super8.call.apply(_super8, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this8), "name", 'SetEditorWidthError');
+    return _this8;
+  }
+  return _createClass(SetEditorWidthError);
+}(CustomError);
+export var SetMetadataError = /*#__PURE__*/function (_CustomError8) {
+  _inherits(SetMetadataError, _CustomError8);
+  var _super9 = _createSuper(SetMetadataError);
+  function SetMetadataError() {
+    var _this9;
+    _classCallCheck(this, SetMetadataError);
+    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      args[_key8] = arguments[_key8];
+    }
+    _this9 = _super9.call.apply(_super9, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this9), "name", 'SetMetadataError');
+    return _this9;
+  }
+  return _createClass(SetMetadataError);
+}(CustomError);
+export var GetCurrentStateError = /*#__PURE__*/function (_CustomError9) {
+  _inherits(GetCurrentStateError, _CustomError9);
+  var _super10 = _createSuper(GetCurrentStateError);
+  function GetCurrentStateError() {
+    var _this10;
+    _classCallCheck(this, GetCurrentStateError);
+    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+      args[_key9] = arguments[_key9];
+    }
+    _this10 = _super10.call.apply(_super10, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this10), "name", 'GetCurrentStateError');
+    return _this10;
+  }
+  return _createClass(GetCurrentStateError);
+}(CustomError);
+export var GetFinalAcknowledgedStateError = /*#__PURE__*/function (_CustomError10) {
+  _inherits(GetFinalAcknowledgedStateError, _CustomError10);
+  var _super11 = _createSuper(GetFinalAcknowledgedStateError);
+  function GetFinalAcknowledgedStateError() {
+    var _this11;
+    _classCallCheck(this, GetFinalAcknowledgedStateError);
+    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+      args[_key10] = arguments[_key10];
+    }
+    _this11 = _super11.call.apply(_super11, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this11), "name", 'GetFinalAcknowledgedStateError');
+    return _this11;
+  }
+  return _createClass(GetFinalAcknowledgedStateError);
+}(CustomError);

package/dist/esm/helpers/utils.js

@@ -8,16 +8,6 @@ export var createLogger = function createLogger(prefix) {
     }
   };
 };
-var logger = createLogger('Helper:util', 'black');
-export var getParticipant = function getParticipant(userId) {
-  logger('getParticipant: ', userId);
-  return {
-    userId: userId,
-    name: userId,
-    avatar: '',
-    email: "".concat(userId.replace(/\s/g, '').toLocaleLowerCase(), "@atlassian.com")
-  };
-};
 export function sleep(ms) {
   return new Promise(function (resolve) {
     setTimeout(resolve, ms);

package/dist/esm/participants/participants-helper.js

@@ -0,0 +1,43 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var PARTICIPANT_UPDATE_INTERVAL = 300 * 1000; // 300 seconds
+
+export var createParticipantFromPayload = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(payload, getUser) {
+    var _user, _user2, _user3;
+    var sessionId, timestamp, clientId, userId, user, participant;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            sessionId = payload.sessionId, timestamp = payload.timestamp, clientId = payload.clientId, userId = payload.userId;
+            if (!getUser) {
+              _context.next = 5;
+              break;
+            }
+            _context.next = 4;
+            return getUser(userId);
+          case 4:
+            user = _context.sent;
+          case 5:
+            participant = {
+              name: ((_user = user) === null || _user === void 0 ? void 0 : _user.name) || '',
+              email: ((_user2 = user) === null || _user2 === void 0 ? void 0 : _user2.email) || '',
+              avatar: ((_user3 = user) === null || _user3 === void 0 ? void 0 : _user3.avatar) || '',
+              sessionId: sessionId,
+              lastActive: timestamp,
+              userId: userId,
+              clientId: clientId
+            };
+            return _context.abrupt("return", participant);
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return function createParticipantFromPayload(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();