@atlaskit/collab-provider 8.2.0 → 8.4.0

package/dist/esm/connectivity/network.js

@@ -0,0 +1,45 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export var NetworkStatus;
+(function (NetworkStatus) {
+  NetworkStatus["ONLINE"] = "ONLINE";
+  NetworkStatus["OFFLINE"] = "OFFLINE";
+})(NetworkStatus || (NetworkStatus = {}));
+var Network = /*#__PURE__*/function () {
+  function Network(props) {
+    var _this = this;
+    _classCallCheck(this, Network);
+    _defineProperty(this, "offlineHandler", function () {
+      _this.status = NetworkStatus.OFFLINE;
+    });
+    _defineProperty(this, "onlineHandler", function () {
+      _this.status = NetworkStatus.ONLINE;
+      if (_this.onlineCallback) {
+        _this.onlineCallback();
+      }
+    });
+    if (props !== null && props !== void 0 && props.initialStatus) {
+      this.status = props.initialStatus;
+    }
+    if (props !== null && props !== void 0 && props.onlineCallback) {
+      this.onlineCallback = props.onlineCallback;
+    }
+    window.addEventListener('offline', this.offlineHandler);
+    window.addEventListener('online', this.onlineHandler);
+  }
+  _createClass(Network, [{
+    key: "getStatus",
+    value: function getStatus() {
+      return this.status || null;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      window.removeEventListener('offline', this.offlineHandler);
+      window.removeEventListener('online', this.onlineHandler);
+    }
+  }]);
+  return Network;
+}();
+export { Network as default };

package/dist/esm/connectivity/reconnect-helper.js

@@ -0,0 +1,42 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { NetworkStatus } from './network';
+import { network } from './singleton';
+
+// Calculation for max 8 offline reconnect attempts, with reconnection delay 200ms, randomization factor 0.5, reconnection delay max 128s
+// Min: 800ms, Avg: 51s, Max: 6m
+var FAILED_RECONNECTS_WHILE_OFFLINE_THRESHOLD = 8;
+var ReconnectHelper = /*#__PURE__*/function () {
+  function ReconnectHelper() {
+    var _this = this;
+    _classCallCheck(this, ReconnectHelper);
+    _defineProperty(this, "failedReconnectCount", 0);
+    _defineProperty(this, "onlineHandler", function () {
+      _this.failedReconnectCount = 0;
+    });
+    window.addEventListener('online', this.onlineHandler);
+  }
+  _createClass(ReconnectHelper, [{
+    key: "countReconnectError",
+    value: function countReconnectError() {
+      // Only count the reconnection attempts when offline
+      if (network.getStatus() === NetworkStatus.OFFLINE) {
+        this.failedReconnectCount++;
+      }
+    }
+  }, {
+    key: "isLikelyNetworkIssue",
+    value: function isLikelyNetworkIssue() {
+      var isLikelyNetworkIssue = this.failedReconnectCount >= FAILED_RECONNECTS_WHILE_OFFLINE_THRESHOLD;
+      return isLikelyNetworkIssue;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      window.removeEventListener('online', this.onlineHandler);
+    }
+  }]);
+  return ReconnectHelper;
+}();
+export { ReconnectHelper as default };

package/dist/esm/connectivity/singleton.js

@@ -0,0 +1,7 @@
+import Network, { NetworkStatus } from './network';
+
+// Assume the connection is established at first
+var network = new Network({
+  initialStatus: NetworkStatus.ONLINE
+});
+export { network };

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

@@ -19,4 +19,20 @@ export var DisconnectReason;
   DisconnectReason["SOCKET_ERROR"] = "SOCKET_ERROR";
   DisconnectReason["SOCKET_TIMEOUT"] = "SOCKET_TIMEOUT";
   DisconnectReason["UNKNOWN_DISCONNECT"] = "UNKNOWN_DISCONNECT";
-})(DisconnectReason || (DisconnectReason = {}));
+})(DisconnectReason || (DisconnectReason = {}));
+export var disconnectedReasonMapper = function disconnectedReasonMapper(reason) {
+  switch (reason) {
+    case socketIOReasons.IO_CLIENT_DISCONNECT:
+      return DisconnectReason.CLIENT_DISCONNECT;
+    case socketIOReasons.IO_SERVER_DISCONNECT:
+      return DisconnectReason.SERVER_DISCONNECT;
+    case socketIOReasons.TRANSPORT_CLOSED:
+      return DisconnectReason.SOCKET_CLOSED;
+    case socketIOReasons.TRANSPORT_ERROR:
+      return DisconnectReason.SOCKET_ERROR;
+    case socketIOReasons.PING_TIMEOUT:
+      return DisconnectReason.SOCKET_TIMEOUT;
+    default:
+      return DisconnectReason.UNKNOWN_DISCONNECT;
+  }
+};

package/dist/esm/{error-code-mapper.js → errors/error-code-mapper.js}

@@ -2,7 +2,7 @@ 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'
+    message: 'User does not have permissions to access this document or document is not found'
   },
   documentNotFound: {
     code: 'DOCUMENT_NOT_FOUND',
@@ -24,6 +24,10 @@ export var ErrorCodeMapper = {
     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'
@@ -54,11 +58,22 @@ export var errorCodeMapper = function errorCodeMapper(error) {
         code: ErrorCodeMapper.failToSave.code,
         message: ErrorCodeMapper.failToSave.message
       };
-    default:
+    case 'DOCUMENT_RESTORE_ERROR':
+      return {
+        status: 500,
+        code: ErrorCodeMapper.restoreError.code,
+        message: ErrorCodeMapper.restoreError.message
+      };
+    // 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':
       return {
         status: 500,
         code: ErrorCodeMapper.internalError.code,
         message: ErrorCodeMapper.internalError.message
       };
+    default:
+      break;
   }
 };

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

@@ -0,0 +1,34 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+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) {
+    var _this;
+    _classCallCheck(this, NotConnectedError);
+    _this = _super.call(this, message);
+    _defineProperty(_assertThisInitialized(_this), "name", 'NotConnectedError');
+    return _this;
+  }
+  return _createClass(NotConnectedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var NotInitializedError = /*#__PURE__*/function (_Error2) {
+  _inherits(NotInitializedError, _Error2);
+  var _super2 = _createSuper(NotInitializedError);
+  function NotInitializedError(message) {
+    var _this2;
+    _classCallCheck(this, NotInitializedError);
+    _this2 = _super2.call(this, message);
+    _defineProperty(_assertThisInitialized(_this2), "name", 'NotInitializedError');
+    return _this2;
+  }
+  return _createClass(NotInitializedError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));

package/dist/esm/helpers/const.js

@@ -1,21 +1,16 @@
-export var EVENT_SUBJECT = 'collab';
-export var COLLAB_SERVICE;
-(function (COLLAB_SERVICE) {
-  COLLAB_SERVICE["NCS"] = "ncs";
-  COLLAB_SERVICE["SYNCHRONY"] = "synchrony";
-})(COLLAB_SERVICE || (COLLAB_SERVICE = {}));
 export var EVENT_ACTION;
 (function (EVENT_ACTION) {
   EVENT_ACTION["CONNECTION"] = "connection";
   EVENT_ACTION["CATCHUP"] = "catchup";
   EVENT_ACTION["DOCUMENT_INIT"] = "documentInit";
   EVENT_ACTION["ADD_STEPS"] = "addSteps";
-  EVENT_ACTION["CONVERT_PM_TO_ADF"] = "convertPMToADF";
   EVENT_ACTION["UPDATE_PARTICIPANTS"] = "updateParticipants";
   EVENT_ACTION["COMMIT_UNCONFIRMED_STEPS"] = "commitUnconfirmedSteps";
   EVENT_ACTION["REINITIALISE_DOCUMENT"] = "reinitialiseDocument";
-  EVENT_ACTION["INIT_PROVIDER"] = "initProvider";
   EVENT_ACTION["ERROR"] = "error";
+  EVENT_ACTION["PUBLISH_PAGE"] = "publishPage";
+  EVENT_ACTION["GET_CURRENT_STATE"] = "getCurrentState";
+  EVENT_ACTION["INVALIDATE_TOKEN"] = "invalidateToken";
 })(EVENT_ACTION || (EVENT_ACTION = {}));
 export var EVENT_STATUS;
 (function (EVENT_STATUS) {

package/dist/esm/provider/catchup.js

@@ -34,7 +34,7 @@ export function rebaseSteps(steps, mapping) {
 }
 export var catchup = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(opt) {
-    var _yield$opt$fetchCatch, doc, serverStepMaps, serverVersion, metadata, currentPmVersion, _ref2, unconfirmedSteps, _ref3, _unconfirmedSteps, stepMaps, mapping, newUnconfirmedSteps;
+    var _yield$opt$fetchCatch, doc, serverStepMaps, serverVersion, metadata, currentPmVersion, unconfirmedSteps, _unconfirmedSteps, stepMaps, mapping, newUnconfirmedSteps;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
@@ -53,9 +53,7 @@ export var catchup = /*#__PURE__*/function () {
                 logger("Could not determine server version");
               } else if (serverVersion <= currentPmVersion) {
                 // there are no step maps in this case after page recovery
-                _ref2 = opt.getUnconfirmedSteps() || {
-                  steps: []
-                }, unconfirmedSteps = _ref2.steps; // replace the entire document
+                unconfirmedSteps = opt.getUnconfirmedSteps(); // replace the entire document
                 logger("Replacing document: ".concat(doc));
                 logger("getting metadata: ".concat(metadata));
                 // Replace local document and version number
@@ -65,15 +63,13 @@ export var catchup = /*#__PURE__*/function () {
                   metadata: metadata,
                   reserveCursor: true
                 });
-                if (unconfirmedSteps.length) {
+                if (unconfirmedSteps !== null && unconfirmedSteps !== void 0 && unconfirmedSteps.length) {
                   opt.applyLocalSteps(unconfirmedSteps);
                 }
               } else {
                 // Please, do not use those steps inside of async
                 // method. That will lead to outdated steps
-                _ref3 = opt.getUnconfirmedSteps() || {
-                  steps: []
-                }, _unconfirmedSteps = _ref3.steps;
+                _unconfirmedSteps = opt.getUnconfirmedSteps();
                 logger("Too far behind[current: v".concat(currentPmVersion, ", server: v").concat(serverVersion, ". ").concat(serverStepMaps.length, " steps need to catchup]"));
                 /**
                  * Remove steps from queue where the version is older than
@@ -100,12 +96,12 @@ export var catchup = /*#__PURE__*/function () {
                 // 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) {
+                if (_unconfirmedSteps !== null && _unconfirmedSteps !== void 0 && _unconfirmedSteps.length) {
                   // Create StepMap from StepMap JSON
                   // eslint-disable-next-line no-unused-vars
-                  stepMaps = serverStepMaps.map(function (_ref4) {
-                    var ranges = _ref4.ranges,
-                      inverted = _ref4.inverted;
+                  stepMaps = serverStepMaps.map(function (_ref2) {
+                    var ranges = _ref2.ranges,
+                      inverted = _ref2.inverted;
                     // Due to @types/prosemirror-transform mismatch with the actual
                     // constructor, hack to set the `inverted`.
                     var stepMap = new StepMap(ranges);

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

@@ -0,0 +1,62 @@
+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; }
+import countBy from 'lodash/countBy';
+import { ADD_STEPS_TYPE, EVENT_ACTION, EVENT_STATUS } from '../helpers/const';
+import { AcknowledgementResponseTypes } from '../types';
+export var commitStep = function commitStep(_ref) {
+  var channel = _ref.channel,
+    steps = _ref.steps,
+    version = _ref.version,
+    userId = _ref.userId,
+    clientId = _ref.clientId,
+    onStepsAdded = _ref.onStepsAdded,
+    onErrorHandled = _ref.onErrorHandled,
+    analyticsHelper = _ref.analyticsHelper;
+  var stepsWithClientAndUserId = steps.map(function (step) {
+    return _objectSpread(_objectSpread({}, step.toJSON()), {}, {
+      clientId: clientId,
+      userId: userId
+    });
+  });
+  var start = new Date().getTime();
+  try {
+    channel.broadcast('steps:commit', {
+      steps: stepsWithClientAndUserId,
+      version: version,
+      userId: userId
+    }, function (response) {
+      var latency = new Date().getTime() - start;
+      if (response.type === AcknowledgementResponseTypes.SUCCESS) {
+        onStepsAdded({
+          steps: stepsWithClientAndUserId,
+          version: response.version
+        });
+        analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendActionEvent(EVENT_ACTION.ADD_STEPS, EVENT_STATUS.SUCCESS, {
+          type: ADD_STEPS_TYPE.ACCEPTED,
+          latency: latency,
+          stepType: countBy(stepsWithClientAndUserId, function (stepWithClientAndUserId) {
+            return 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,
+          latency: latency
+        });
+        analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendErrorEvent(response.error, 'Error while adding steps - Acknowledgement Error');
+      } else {
+        analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendErrorEvent(
+        // @ts-expect-error We didn't type the invalid type case
+        new Error("Response type: ".concat((response === null || response === void 0 ? void 0 : response.type) || 'No response type')), 'Error while adding steps - Invalid Acknowledgement');
+      }
+    });
+  } catch (error) {
+    analyticsHelper === null || analyticsHelper === void 0 ? void 0 : analyticsHelper.sendErrorEvent(error, 'Error while adding steps - Broadcast threw exception');
+  }
+};