@atlaskit/collab-provider 8.4.0 → 8.5.0

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

@@ -0,0 +1,209 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { disconnectedReasonMapper } from '../disconnected-reason-mapper';
+import { EVENT_ACTION, EVENT_STATUS } from '../helpers/const';
+import { telepointerFromStep } from './telepointers-helper';
+import { createParticipantFromPayload as enrichParticipant, PARTICIPANT_UPDATE_INTERVAL } from './participants-helper';
+import { ParticipantsState } from './participants-state';
+export var ParticipantsService = /*#__PURE__*/function () {
+  function ParticipantsService(analyticsHelper) {
+    var _this = this;
+    var participantsState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new ParticipantsState();
+    _classCallCheck(this, ParticipantsService);
+    _defineProperty(this, "updateParticipant", /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(payload, getUser, emit) {
+        var userId, participant, _this$analyticsHelper, isNewParticipant;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                userId = payload.userId; // If userId does not exist, does nothing here to prevent duplication.
+                if (userId) {
+                  _context.next = 3;
+                  break;
+                }
+                return _context.abrupt("return");
+              case 3:
+                _context.prev = 3;
+                _context.next = 6;
+                return enrichParticipant( // userId _must_ be defined, this lets the compiler know
+                _objectSpread(_objectSpread({}, payload), {}, {
+                  userId: userId
+                }), getUser);
+              case 6:
+                participant = _context.sent;
+                _context.next = 12;
+                break;
+              case 9:
+                _context.prev = 9;
+                _context.t0 = _context["catch"](3);
+                // We don't want to throw errors for Presence features as they tend to self-restore
+                (_this$analyticsHelper = _this.analyticsHelper) === null || _this$analyticsHelper === void 0 ? void 0 : _this$analyticsHelper.sendErrorEvent(_context.t0, 'enriching participant');
+              case 12:
+                if (participant) {
+                  _context.next = 14;
+                  break;
+                }
+                return _context.abrupt("return");
+              case 14:
+                isNewParticipant = _this.participantsState.doesntHave(participant.sessionId);
+                _this.participantsState.setBySessionId(participant.sessionId, participant);
+                if (isNewParticipant) {
+                  _context.next = 18;
+                  break;
+                }
+                return _context.abrupt("return");
+              case 18:
+                _this.emitPresence({
+                  joined: [participant]
+                }, emit, 'handling participant updated event');
+              case 19:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[3, 9]]);
+      }));
+      return function (_x, _x2, _x3) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    _defineProperty(this, "participantLeft", function (_ref2, emit) {
+      var sessionId = _ref2.sessionId;
+      _this.participantsState.removeBySessionId(sessionId);
+      _this.emitPresence({
+        left: [{
+          sessionId: sessionId
+        }]
+      }, emit, 'participant leaving');
+    });
+    _defineProperty(this, "disconnect", function (reason, sessionId, emit) {
+      var left = _this.participantsState.getParticipants();
+      _this.participantsState.clear();
+      try {
+        emit('disconnected', {
+          reason: disconnectedReasonMapper(reason),
+          sid: sessionId
+        });
+      } catch (error) {
+        var _this$analyticsHelper2;
+        // We don't want to throw errors for Presence features as they tend to self-restore
+        (_this$analyticsHelper2 = _this.analyticsHelper) === null || _this$analyticsHelper2 === void 0 ? void 0 : _this$analyticsHelper2.sendErrorEvent(error, 'emitting disconnected data');
+      }
+      if (left.length) {
+        _this.emitPresence({
+          left: left
+        }, emit, 'emitting presence update on disconnect');
+      }
+    });
+    _defineProperty(this, "updateLastActive", function () {
+      var userIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return _this.participantsState.updateLastActive(Date.now(), userIds);
+    });
+    _defineProperty(this, "participantTelepointer", function (payload, thisSessionId, getUser, emit) {
+      var sessionId = payload.sessionId,
+        selection = payload.selection,
+        timestamp = payload.timestamp;
+      var participant = _this.participantsState.getBySessionId(sessionId);
+      if (sessionId === thisSessionId ||
+      // Ignore old telepointer events
+      participant && participant.lastActive > timestamp) {
+        return;
+      }
+      var userId = payload.userId ? [payload.userId] : undefined;
+
+      // Set last active
+      _this.updateLastActive(userId);
+      _this.emitTelepointer({
+        type: 'telepointer',
+        selection: selection,
+        sessionId: sessionId
+      }, emit, 'handling participant telepointer event');
+    });
+    _defineProperty(this, "removeInactiveParticipants", function (sessionId, emit) {
+      clearTimeout(_this.participantUpdateTimeout);
+      try {
+        _this.filterInactive(sessionId, emit);
+      } catch (err) {
+        var _this$analyticsHelper3;
+        (_this$analyticsHelper3 = _this.analyticsHelper) === null || _this$analyticsHelper3 === void 0 ? void 0 : _this$analyticsHelper3.sendErrorEvent(err, 'Failed filtering inactive participants');
+      }
+      _this.participantUpdateTimeout = window.setTimeout(function () {
+        return _this.removeInactiveParticipants(sessionId, emit);
+      }, PARTICIPANT_UPDATE_INTERVAL);
+    });
+    _defineProperty(this, "filterInactive", function (sessionId, emit) {
+      var now = Date.now();
+      var left = _this.participantsState.getParticipants().filter(function (p) {
+        return p.sessionId !== sessionId && now - p.lastActive > PARTICIPANT_UPDATE_INTERVAL;
+      });
+      left.forEach(function (p) {
+        return _this.participantsState.removeBySessionId(p.sessionId);
+      });
+      _this.emitPresence({
+        left: left
+      }, emit, 'filtering inactive participants');
+    });
+    _defineProperty(this, "emitPresence", function (data, emit, errorMessage) {
+      try {
+        var _this$analyticsHelper4;
+        emit('presence', data);
+        (_this$analyticsHelper4 = _this.analyticsHelper) === null || _this$analyticsHelper4 === void 0 ? void 0 : _this$analyticsHelper4.sendActionEvent(EVENT_ACTION.UPDATE_PARTICIPANTS, EVENT_STATUS.SUCCESS, {
+          participants: _this.participantsState.size()
+        });
+      } catch (error) {
+        var _this$analyticsHelper5;
+        // We don't want to throw errors for Presence features as they tend to self-restore
+        (_this$analyticsHelper5 = _this.analyticsHelper) === null || _this$analyticsHelper5 === void 0 ? void 0 : _this$analyticsHelper5.sendErrorEvent(error, "Error while ".concat(errorMessage));
+      }
+    });
+    _defineProperty(this, "emitTelepointer", function (data, emit, errorMessage) {
+      try {
+        emit('telepointer', data);
+      } catch (error) {
+        var _this$analyticsHelper6;
+        // We don't want to throw errors for Presence features as they tend to self-restore
+        (_this$analyticsHelper6 = _this.analyticsHelper) === null || _this$analyticsHelper6 === void 0 ? void 0 : _this$analyticsHelper6.sendErrorEvent(error, "Error while ".concat(errorMessage));
+      }
+    });
+    this.participantsState = participantsState;
+    this.analyticsHelper = analyticsHelper;
+  }
+
+  /**
+   * Carries out 3 things: 1) enriches the participant with user data, 2) updates the participantsState, 3) emits the presence event
+   * @param payload Payload from incoming socket event
+   * @param getUser Function to get user data from confluence
+   * @param emit Function to execute emit from provider socket
+   * @returns Awaitable Promise, due to getUser
+   */
+  _createClass(ParticipantsService, [{
+    key: "emitTelepointersFromSteps",
+    value:
+    /**
+     * Called on receiving steps, emits each step's telepointer
+     * @param steps Steps to extract telepointers from
+     * @param emit Provider emit function
+     */
+    function emitTelepointersFromSteps(steps, emit) {
+      var _this2 = this;
+      steps.forEach(function (step) {
+        var event = telepointerFromStep(_this2.participantsState.getParticipants(), step);
+        if (event) {
+          _this2.emitTelepointer(event, emit, 'emitting telepointers from steps');
+        }
+      });
+    }
+
+    /**
+     * Called when we receive a telepointer update from another
+     * participant.
+     */
+  }]);
+  return ParticipantsService;
+}();

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

@@ -0,0 +1,45 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+export var ParticipantsState = /*#__PURE__*/_createClass(function ParticipantsState() {
+  var _this = this;
+  var baseParticipants = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
+  _classCallCheck(this, ParticipantsState);
+  _defineProperty(this, "getBySessionId", function (sessionId) {
+    var participant = _this.participants.get(sessionId);
+    // Spread to ensure we get a deep copy
+    return participant ? _objectSpread({}, participant) : undefined;
+  });
+  _defineProperty(this, "setBySessionId", function (sessionId, participant) {
+    _this.participants.set(sessionId, participant);
+  });
+  _defineProperty(this, "getParticipants", function () {
+    return (
+      // Spread to get deep copy
+      _toConsumableArray(_this.participants.values()).map(function (p) {
+        return _objectSpread({}, p);
+      })
+    );
+  });
+  _defineProperty(this, "removeBySessionId", function (sessionId) {
+    return _this.participants.delete(sessionId);
+  });
+  _defineProperty(this, "clear", function () {
+    return _this.participants.clear();
+  });
+  _defineProperty(this, "doesntHave", function (sessionId) {
+    return !_this.participants.has(sessionId);
+  });
+  _defineProperty(this, "size", function () {
+    return _this.participants.size;
+  });
+  _defineProperty(this, "updateLastActive", function (now, userIds) {
+    return _this.participants.forEach(function (p) {
+      p.lastActive = userIds.includes(p.userId) ? now : p.lastActive;
+    });
+  });
+  this.participants = baseParticipants;
+});

package/dist/esm/{provider/telepointers.js → participants/telepointers-helper.js}

@@ -4,12 +4,12 @@ import { createLogger } from '../helpers/utils';
 import { ExperiencePerformanceTypes, ExperienceTypes, UFOExperience } from '@atlaskit/ufo';
 import { AcknowledgementResponseTypes } from '../types';
 var logger = createLogger('Telepointer', 'green');
-export var telepointersFromStep = function telepointersFromStep(participants, step) {
-  var _Array$from$filter = Array.from(participants.values()).filter(function (p) {
+export var telepointerFromStep = function telepointerFromStep(participants, step) {
+  var _participants$filter = participants.filter(function (p) {
       return p.clientId === step.clientId;
     }),
-    _Array$from$filter2 = _slicedToArray(_Array$from$filter, 1),
-    participant = _Array$from$filter2[0];
+    _participants$filter2 = _slicedToArray(_participants$filter, 1),
+    participant = _participants$filter2[0];
   if (participant) {
     var _node$text;
     var stepType = step.stepType,

package/dist/esm/provider/commit-step.js

@@ -4,8 +4,9 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 import countBy from 'lodash/countBy';
 import { ADD_STEPS_TYPE, EVENT_ACTION, EVENT_STATUS } from '../helpers/const';
 import { AcknowledgementResponseTypes } from '../types';
+import { NCS_ERROR_CODE } from '../errors/error-types';
 export var commitStep = function commitStep(_ref) {
-  var channel = _ref.channel,
+  var broadcast = _ref.broadcast,
     steps = _ref.steps,
     version = _ref.version,
     userId = _ref.userId,
@@ -21,7 +22,7 @@ export var commitStep = function commitStep(_ref) {
   });
   var start = new Date().getTime();
   try {
-    channel.broadcast('steps:commit', {
+    broadcast('steps:commit', {
       steps: stepsWithClientAndUserId,
       version: version,
       userId: userId
@@ -40,13 +41,12 @@ export var commitStep = function commitStep(_ref) {
           })
         });
       } else if (response.type === AcknowledgementResponseTypes.ERROR) {
-        var _response$error, _response$error$data, _response$error2, _response$error2$data;
         onErrorHandled(response.error);
         analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendActionEvent(EVENT_ACTION.ADD_STEPS, EVENT_STATUS.FAILURE, {
           // User tried committing steps but they were rejected because:
           // - HEAD_VERSION_UPDATE_FAILED: the collab service's latest stored step tail version didn't correspond to the head version of the first step submitted
           // - VERSION_NUMBER_ALREADY_EXISTS: while storing the steps there was a conflict meaning someone else wrote steps into the database more quickly
-          type: ((_response$error = response.error) === null || _response$error === void 0 ? void 0 : (_response$error$data = _response$error.data) === null || _response$error$data === void 0 ? void 0 : _response$error$data.code) === 'HEAD_VERSION_UPDATE_FAILED' || ((_response$error2 = response.error) === null || _response$error2 === void 0 ? void 0 : (_response$error2$data = _response$error2.data) === null || _response$error2$data === void 0 ? void 0 : _response$error2$data.code) === 'VERSION_NUMBER_ALREADY_EXISTS' ? ADD_STEPS_TYPE.REJECTED : ADD_STEPS_TYPE.ERROR,
+          type: response.error.data.code === NCS_ERROR_CODE.HEAD_VERSION_UPDATE_FAILED || response.error.data.code === NCS_ERROR_CODE.VERSION_NUMBER_ALREADY_EXISTS ? ADD_STEPS_TYPE.REJECTED : ADD_STEPS_TYPE.ERROR,
           latency: latency
         });
         analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendErrorEvent(response.error, 'Error while adding steps - Acknowledgement Error');