@atlaskit/collab-provider 8.4.0 → 8.5.0

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

@@ -1,78 +1,102 @@
-export const 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 const 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/es2019/errors/error-types.js

@@ -1,13 +1,151 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-export class NotConnectedError extends Error {
-  constructor(message) {
+// Internal error codes (generated by collab provider)
+export let 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 let 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 let 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
+class CustomError extends Error {
+  constructor(message, error) {
     super(message);
+    if (typeof (error === null || error === void 0 ? void 0 : error.message) === 'string') {
+      this.message = error.message;
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message
+    };
+  }
+}
+export class NotConnectedError extends CustomError {
+  constructor(...args) {
+    super(...args);
     _defineProperty(this, "name", 'NotConnectedError');
   }
 }
-export class NotInitializedError extends Error {
-  constructor(message) {
-    super(message);
+export class NotInitializedError extends CustomError {
+  constructor(...args) {
+    super(...args);
     _defineProperty(this, "name", 'NotInitializedError');
   }
+}
+export class ProviderInitialisationError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'ProviderInitialisationError');
+  }
+}
+export class SendTransactionError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'SendTransactionError');
+  }
+}
+export class DestroyError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'DestroyError');
+  }
+}
+export class SetTitleError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'SetTitleError');
+  }
+}
+export class SetEditorWidthError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'SetEditorWidthError');
+  }
+}
+export class SetMetadataError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'SetMetadataError');
+  }
+}
+export class GetCurrentStateError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'GetCurrentStateError');
+  }
+}
+export class GetFinalAcknowledgedStateError extends CustomError {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'GetFinalAcknowledgedStateError');
+  }
 }

package/dist/es2019/helpers/utils.js

@@ -4,16 +4,6 @@ export const createLogger = (prefix, color = 'blue') => (msg, data = null) => {
     console.log(`%cCollab-${prefix}: ${msg}`, `color: ${color}; font-weight: bold`, data);
   }
 };
-const logger = createLogger('Helper:util', 'black');
-export const getParticipant = userId => {
-  logger('getParticipant: ', userId);
-  return {
-    userId: userId,
-    name: userId,
-    avatar: '',
-    email: `${userId.replace(/\s/g, '').toLocaleLowerCase()}@atlassian.com`
-  };
-};
 export function sleep(ms) {
   return new Promise(resolve => {
     setTimeout(resolve, ms);

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

@@ -0,0 +1,25 @@
+export const PARTICIPANT_UPDATE_INTERVAL = 300 * 1000; // 300 seconds
+
+export const createParticipantFromPayload = async (payload, getUser) => {
+  var _user, _user2, _user3;
+  const {
+    sessionId,
+    timestamp,
+    clientId,
+    userId
+  } = payload;
+  let user;
+  if (getUser) {
+    user = await getUser(userId);
+  }
+  const 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,
+    lastActive: timestamp,
+    userId,
+    clientId
+  };
+  return participant;
+};

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

@@ -0,0 +1,166 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 class ParticipantsService {
+  constructor(analyticsHelper, participantsState = new ParticipantsState()) {
+    _defineProperty(this, "updateParticipant", async (payload, getUser, emit) => {
+      const {
+        userId
+      } = payload;
+
+      // If userId does not exist, does nothing here to prevent duplication.
+      if (!userId) {
+        return;
+      }
+      let participant;
+      // getUser is a failable callback, hence try-catch
+      try {
+        participant = await enrichParticipant(
+        // userId _must_ be defined, this lets the compiler know
+        {
+          ...payload,
+          userId
+        }, getUser);
+      } catch (error) {
+        var _this$analyticsHelper;
+        // 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(error, 'enriching participant');
+      }
+      if (!participant) {
+        return;
+      }
+      const isNewParticipant = this.participantsState.doesntHave(participant.sessionId);
+      this.participantsState.setBySessionId(participant.sessionId, participant);
+      if (!isNewParticipant) {
+        return;
+      }
+      this.emitPresence({
+        joined: [participant]
+      }, emit, 'handling participant updated event');
+    });
+    _defineProperty(this, "participantLeft", ({
+      sessionId
+    }, emit) => {
+      this.participantsState.removeBySessionId(sessionId);
+      this.emitPresence({
+        left: [{
+          sessionId
+        }]
+      }, emit, 'participant leaving');
+    });
+    _defineProperty(this, "disconnect", (reason, sessionId, emit) => {
+      const 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
+        }, emit, 'emitting presence update on disconnect');
+      }
+    });
+    _defineProperty(this, "updateLastActive", (userIds = []) => this.participantsState.updateLastActive(Date.now(), userIds));
+    _defineProperty(this, "participantTelepointer", (payload, thisSessionId, getUser, emit) => {
+      const {
+        sessionId,
+        selection,
+        timestamp
+      } = payload;
+      const participant = this.participantsState.getBySessionId(sessionId);
+      if (sessionId === thisSessionId ||
+      // Ignore old telepointer events
+      participant && participant.lastActive > timestamp) {
+        return;
+      }
+      const userId = payload.userId ? [payload.userId] : undefined;
+
+      // Set last active
+      this.updateLastActive(userId);
+      this.emitTelepointer({
+        type: 'telepointer',
+        selection,
+        sessionId
+      }, emit, 'handling participant telepointer event');
+    });
+    _defineProperty(this, "removeInactiveParticipants", (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(() => this.removeInactiveParticipants(sessionId, emit), PARTICIPANT_UPDATE_INTERVAL);
+    });
+    _defineProperty(this, "filterInactive", (sessionId, emit) => {
+      const now = Date.now();
+      const left = this.participantsState.getParticipants().filter(p => p.sessionId !== sessionId && now - p.lastActive > PARTICIPANT_UPDATE_INTERVAL);
+      left.forEach(p => this.participantsState.removeBySessionId(p.sessionId));
+      this.emitPresence({
+        left
+      }, emit, 'filtering inactive participants');
+    });
+    _defineProperty(this, "emitPresence", (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 ${errorMessage}`);
+      }
+    });
+    _defineProperty(this, "emitTelepointer", (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 ${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
+   */
+
+  /**
+   * Called on receiving steps, emits each step's telepointer
+   * @param steps Steps to extract telepointers from
+   * @param emit Provider emit function
+   */
+  emitTelepointersFromSteps(steps, emit) {
+    steps.forEach(step => {
+      const event = telepointerFromStep(this.participantsState.getParticipants(), step);
+      if (event) {
+        this.emitTelepointer(event, emit, 'emitting telepointers from steps');
+      }
+    });
+  }
+
+  /**
+   * Called when we receive a telepointer update from another
+   * participant.
+   */
+}

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

@@ -0,0 +1,28 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export class ParticipantsState {
+  constructor(baseParticipants = new Map()) {
+    _defineProperty(this, "getBySessionId", sessionId => {
+      const participant = this.participants.get(sessionId);
+      // Spread to ensure we get a deep copy
+      return participant ? {
+        ...participant
+      } : undefined;
+    });
+    _defineProperty(this, "setBySessionId", (sessionId, participant) => {
+      this.participants.set(sessionId, participant);
+    });
+    _defineProperty(this, "getParticipants", () =>
+    // Spread to get deep copy
+    [...this.participants.values()].map(p => ({
+      ...p
+    })));
+    _defineProperty(this, "removeBySessionId", sessionId => this.participants.delete(sessionId));
+    _defineProperty(this, "clear", () => this.participants.clear());
+    _defineProperty(this, "doesntHave", sessionId => !this.participants.has(sessionId));
+    _defineProperty(this, "size", () => this.participants.size);
+    _defineProperty(this, "updateLastActive", (now, userIds) => this.participants.forEach(p => {
+      p.lastActive = userIds.includes(p.userId) ? now : p.lastActive;
+    }));
+    this.participants = baseParticipants;
+  }
+}

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

@@ -2,8 +2,8 @@ import { createLogger } from '../helpers/utils';
 import { ExperiencePerformanceTypes, ExperienceTypes, UFOExperience } from '@atlaskit/ufo';
 import { AcknowledgementResponseTypes } from '../types';
 const logger = createLogger('Telepointer', 'green');
-export const telepointersFromStep = (participants, step) => {
-  const [participant] = Array.from(participants.values()).filter(p => p.clientId === step.clientId);
+export const telepointerFromStep = (participants, step) => {
+  const [participant] = participants.filter(p => p.clientId === step.clientId);
   if (participant) {
     var _node$text;
     const {

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

@@ -1,8 +1,9 @@
 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 const commitStep = ({
-  channel,
+  broadcast,
   steps,
   version,
   userId,
@@ -18,7 +19,7 @@ export const commitStep = ({
   }));
   const start = new Date().getTime();
   try {
-    channel.broadcast('steps:commit', {
+    broadcast('steps:commit', {
       steps: stepsWithClientAndUserId,
       version,
       userId
@@ -35,13 +36,12 @@ export const commitStep = ({
           stepType: countBy(stepsWithClientAndUserId, stepWithClientAndUserId => stepWithClientAndUserId.stepType)
         });
       } 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
         });
         analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendErrorEvent(response.error, 'Error while adding steps - Acknowledgement Error');