@atlaskit/collab-provider 7.0.0 → 7.1.2

package/dist/cjs/socket-io-provider.js

@@ -5,8 +5,8 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createSocketIOSocket = createSocketIOSocket;
 exports.createSocketIOCollabProvider = createSocketIOCollabProvider;
+exports.createSocketIOSocket = createSocketIOSocket;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/collab-provider",
-	"version": "7.0.0",
+	"version": "7.1.2",
 	"sideEffects": false
 }

package/dist/es2019/channel.js

@@ -3,6 +3,8 @@ import { utils } from '@atlaskit/util-service-support';
 import { Emitter } from './emitter';
 import { ErrorCodeMapper } from './error-code-mapper';
 import { createLogger } from './helpers/utils';
+import { startMeasure, stopMeasure } from './analytics/performance';
+import { triggerAnalyticsForCatchupSuccessfulWithLatency } from './analytics';
 const logger = createLogger('Channel', 'green');
 export class Channel extends Emitter {
   constructor(config) {
@@ -55,6 +57,10 @@ export class Channel extends Emitter {
     });
 
     this.config = config;
+
+    if (config.analyticsClient) {
+      this.analyticsClient = config.analyticsClient;
+    }
   } // read-only getters used for tests
 
 
@@ -110,8 +116,11 @@ export class Channel extends Emitter {
     this.socket.on('participant:telepointer', payload => {
       this.emit('participant:telepointer', payload.data);
     });
-    this.socket.on('participant:joined', data => {
-      this.emit('participant:joined', data);
+    this.socket.on('presence:joined', data => {
+      this.emit('presence:joined', data);
+    });
+    this.socket.on('presence', data => {
+      this.emit('presence', data);
     });
     this.socket.on('participant:left', data => {
       this.emit('participant:left', data);
@@ -129,11 +138,8 @@ export class Channel extends Emitter {
         ...data
       });
     });
-    this.socket.on('title:changed', payload => {
-      this.emit('title:changed', payload.data);
-    });
-    this.socket.on('width:changed', payload => {
-      this.emit('width:changed', payload.data);
+    this.socket.on('metadata:changed', payload => {
+      this.emit('metadata:changed', payload);
     });
     this.socket.on('disconnect', async reason => {
       this.connected = false;
@@ -173,6 +179,7 @@ export class Channel extends Emitter {
 
   async fetchCatchup(fromVersion) {
     try {
+      startMeasure('callingCatchupApi');
       const {
         doc,
         version,
@@ -208,6 +215,10 @@ export class Channel extends Emitter {
       };
       this.emit('error', errorCatchup);
       return {};
+    } finally {
+      stopMeasure('callingCatchupApi', (duration, _) => {
+        triggerAnalyticsForCatchupSuccessfulWithLatency(this.analyticsClient, duration);
+      });
     }
   }
   /**
@@ -226,6 +237,22 @@ export class Channel extends Emitter {
     });
   }
 
+  sendMetadata(metadata) {
+    if (!this.connected || !this.socket) {
+      return;
+    }
+
+    this.socket.emit('metadata', metadata);
+  }
+
+  sendPresenceJoined() {
+    if (!this.connected || !this.socket) {
+      return;
+    }
+
+    this.socket.emit('presence:joined');
+  }
+
   disconnect() {
     this.unsubscribeAll();
 

package/dist/es2019/disconnected-reason-mapper.js

@@ -0,0 +1,23 @@
+// See https://socket.io/docs/v3/client-socket-instance#disconnect for emitted reasons
+export const socketIOReasons = {
+  IO_CLIENT_DISCONNECT: 'io client disconnect',
+  // The socket was manually disconnected using socket.disconnect()
+  IO_SERVER_DISCONNECT: 'io server disconnect',
+  // The server has forcefully disconnected the socket with socket.disconnect()
+  TRANSPORT_CLOSED: 'transport close',
+  // The server did not send a PING within the pingInterval + pingTimeout range
+  TRANSPORT_ERROR: 'transport error',
+  // The connection was closed (example: the user has lost connection, or the network was changed from WiFi to 4G)
+  PING_TIMEOUT: 'ping timeout' // The connection has encountered an error (example: the server was killed during a HTTP long-polling cycle)
+
+};
+export let DisconnectReason;
+
+(function (DisconnectReason) {
+  DisconnectReason["CLIENT_DISCONNECT"] = "CLIENT_DISCONNECT";
+  DisconnectReason["SERVER_DISCONNECT"] = "SERVER_DISCONNECT";
+  DisconnectReason["SOCKET_CLOSED"] = "SOCKET_CLOSED";
+  DisconnectReason["SOCKET_ERROR"] = "SOCKET_ERROR";
+  DisconnectReason["SOCKET_TIMEOUT"] = "SOCKET_TIMEOUT";
+  DisconnectReason["UNKNOWN_DISCONNECT"] = "UNKNOWN_DISCONNECT";
+})(DisconnectReason || (DisconnectReason = {}));

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

@@ -27,4 +27,42 @@ export const ErrorCodeMapper = {
     code: 'INTERNAL_SERVICE_ERROR',
     message: 'Collab service has return internal server error'
   }
+};
+export const errorCodeMapper = error => {
+  if (error.data) {
+    switch (error.data.code) {
+      case 'INSUFFICIENT_EDITING_PERMISSION':
+        return {
+          status: 403,
+          code: ErrorCodeMapper.noPermissionError.code,
+          message: ErrorCodeMapper.noPermissionError.message
+        };
+
+      case 'DOCUMENT_NOT_FOUND':
+        return {
+          status: 404,
+          code: ErrorCodeMapper.documentNotFound.code,
+          message: ErrorCodeMapper.documentNotFound.message
+        };
+
+      case 'FAILED_ON_S3':
+      case 'DYNAMO_ERROR':
+        return {
+          status: 500,
+          code: ErrorCodeMapper.failToSave.code,
+          message: ErrorCodeMapper.failToSave.message
+        };
+
+      case 'CATCHUP_FAILED':
+      case 'GET_QUERY_TIME_OUT':
+        return {
+          status: 500,
+          code: ErrorCodeMapper.internalError.code,
+          message: ErrorCodeMapper.internalError.message
+        };
+
+      default:
+        break;
+    }
+  }
 };

package/dist/es2019/helpers/utils.js

@@ -1,23 +1,18 @@
 export const createLogger = (prefix, color = 'blue') => (msg, data = null) => {
   if (window.COLLAB_PROVIDER_LOGGER) {
     // eslint-disable-next-line no-console
-    console.log(`%cCollab-${prefix}: ${msg}`, `color: ${color}; font-weight: bold`);
-
-    if (data) {
-      // eslint-disable-next-line no-console
-      console.log(data);
-    }
+    console.log(`%cCollab-${prefix}: ${msg}`, `color: ${color}; font-weight: bold`, data);
   }
 };
+const logger = createLogger('Helper:util', 'black');
 export const getParticipant = userId => {
-  // eslint-disable-next-line no-bitwise
-  const name = 'Demo User';
-  return Promise.resolve({
-    userId,
-    name,
-    avatar: `https://api.adorable.io/avatars/80/${name.replace(/\s/g, '')}.png`,
-    email: `${name.replace(/\s/g, '').toLocaleLowerCase()}@atlassian.com`
-  });
+  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 => {

package/dist/es2019/provider/catchup.js

@@ -0,0 +1,91 @@
+import { createLogger } from '../helpers/utils';
+import { StepMap, Mapping } from 'prosemirror-transform';
+const logger = createLogger('Catchup', 'red');
+/**
+ * Rebase the steps based on the mapping pipeline.
+ * Some steps could be lost, if they are no longer
+ * invalid after rebased.
+ */
+
+export function rebaseSteps(steps, mapping) {
+  const newSteps = [];
+
+  for (const step of steps) {
+    const newStep = step.map(mapping); // newStep could be null(means invalid after rebase) when can't rebase.
+
+    if (newStep) {
+      newSteps.push(newStep);
+    }
+  }
+
+  return newSteps;
+}
+export const catchup = async opt => {
+  const {
+    doc,
+    stepMaps: serverStepMaps,
+    version: serverVersion,
+    metadata
+  } = await opt.fetchCatchup(opt.getCurrentPmVersion());
+
+  if (doc) {
+    const currentPmVersion = opt.getCurrentPmVersion();
+
+    if (typeof serverVersion === 'undefined') {
+      logger(`Could not determine server version`);
+    } else if (serverVersion <= currentPmVersion) {
+      logger(`Catchup steps we already have. Ignoring.`);
+    } else {
+      // Please, do not use those steps inside of async
+      // method. That will lead to outdated steps
+      const {
+        steps: unconfirmedSteps
+      } = opt.getUnconfirmedSteps() || {
+        steps: []
+      };
+      logger(`Too far behind[current: v${currentPmVersion}, server: v${serverVersion}. ${serverStepMaps.length} steps need to catchup]`);
+      /**
+       * Remove steps from queue where the version is older than
+       * the version we received from service. Keep steps that might be
+       * newer.
+       */
+
+      opt.fitlerQueue(data => data.version > serverVersion); // We are too far behind - replace the entire document
+
+      logger(`Replacing document: ${doc}`);
+      logger(`getting metadata: ${metadata}`); // Replace local document and version number
+
+      opt.updateDocumentWithMetadata({
+        doc: JSON.parse(doc),
+        version: serverVersion,
+        metadata,
+        reserveCursor: true
+      }); // After replacing the whole document in the editor, we need to reapply the unconfirmed
+      // steps back into the editor, so we don't lose any data. But before that, we need to rebase
+      // those steps since their position could be changed after replacing.
+      // https://prosemirror.net/docs/guide/#transform.rebasing
+
+      if (unconfirmedSteps.length) {
+        // Create StepMap from StepMap JSON
+        // eslint-disable-next-line no-unused-vars
+        const stepMaps = serverStepMaps.map(({
+          ranges,
+          inverted
+        }) => {
+          // Due to @types/prosemirror-transform mismatch with the actual
+          // constructor, hack to set the `inverted`.
+          const stepMap = new StepMap(ranges);
+          stepMap.inverted = inverted;
+          return stepMap;
+        }); // create Mappng used for Step.map
+
+        const mapping = new Mapping(stepMaps);
+        logger(`${unconfirmedSteps.length} unconfirmed steps before rebased: ${JSON.stringify(unconfirmedSteps)}`);
+        const newUnconfirmedSteps = rebaseSteps(unconfirmedSteps, mapping);
+        logger(`Re-aply ${newUnconfirmedSteps.length} mapped unconfirmed steps: ${JSON.stringify(newUnconfirmedSteps)}`); // Re-aply local steps
+
+        opt.applyLocalsteps(newUnconfirmedSteps);
+      }
+    }
+  }
+};