@atlaskit/collab-provider 8.1.0 → 8.3.0

package/dist/esm/emitter.js

@@ -5,10 +5,8 @@ import { EventEmitter2 } from 'eventemitter2';
 export var Emitter = /*#__PURE__*/function () {
   function Emitter() {
     _classCallCheck(this, Emitter);
-
     _defineProperty(this, "eventEmitter", new EventEmitter2());
   }
-
   _createClass(Emitter, [{
     key: "emit",
     value:
@@ -19,30 +17,30 @@ export var Emitter = /*#__PURE__*/function () {
       this.eventEmitter.emit(evt, data);
       return this;
     }
+
     /**
      * Subscribe to events emitted by this provider
      */
-
   }, {
     key: "on",
     value: function on(evt, handler) {
       this.eventEmitter.on(evt, handler);
       return this;
     }
+
     /**
      * Unsubscribe from events emitted by this provider
      */
-
   }, {
     key: "off",
     value: function off(evt, handler) {
       this.eventEmitter.off(evt, handler);
       return this;
     }
+
     /**
      * Unsubscribe from all events emitted by this provider.
      */
-
   }, {
     key: "unsubscribeAll",
     value: function unsubscribeAll(evt) {
@@ -50,6 +48,5 @@ export var Emitter = /*#__PURE__*/function () {
       return this;
     }
   }]);
-
   return Emitter;
 }();

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

@@ -24,31 +24,33 @@ 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 return internal server error'
+    message: 'Collab service has experienced an internal server error'
   }
 };
 export var errorCodeMapper = function errorCodeMapper(error) {
   var _error$data;
-
   switch ((_error$data = error.data) === null || _error$data === void 0 ? void 0 : _error$data.code) {
     case 'INSUFFICIENT_EDITING_PERMISSION':
       return {
         status: 403,
         code: ErrorCodeMapper.noPermissionError.code,
         message: ErrorCodeMapper.noPermissionError.message,
-        reason: // Typescript magic so it detects the union type
+        reason:
+        // Typescript magic so it detects the union type
         _typeof(error.data.meta) === 'object' ? error.data.meta.reason : undefined
       };
-
     case 'DOCUMENT_NOT_FOUND':
       return {
         status: 404,
         code: ErrorCodeMapper.documentNotFound.code,
         message: ErrorCodeMapper.documentNotFound.message
       };
-
     case 'FAILED_ON_S3':
     case 'DYNAMO_ERROR':
       return {
@@ -56,7 +58,13 @@ export var errorCodeMapper = function errorCodeMapper(error) {
         code: ErrorCodeMapper.failToSave.code,
         message: ErrorCodeMapper.failToSave.message
       };
-
+    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':
@@ -65,7 +73,6 @@ export var errorCodeMapper = function errorCodeMapper(error) {
         code: ErrorCodeMapper.internalError.code,
         message: ErrorCodeMapper.internalError.message
       };
-
     default:
       break;
   }

package/dist/esm/feature-flags/index.js

@@ -2,37 +2,33 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 var defaultNCSFeatureFlags = {
   testFF: false
 };
+
 /**
  * Note that Confluence should have the same FF sets as NCS
  */
-
 var productKeys = {
   confluence: {
     testFF: 'confluence.fe.collab.provider.testFF'
   }
 };
-
 var filterFeatureFlagNames = function filterFeatureFlagNames(flags) {
   var pairs = Object.entries(flags);
   return pairs.filter(function (_ref) {
     var _ref2 = _slicedToArray(_ref, 2),
-        _key = _ref2[0],
-        value = _ref2[1];
-
+      _key = _ref2[0],
+      value = _ref2[1];
     return !!value;
   }).map(function (_ref3) {
     var _ref4 = _slicedToArray(_ref3, 1),
-        key = _ref4[0];
-
+      key = _ref4[0];
     return key;
   });
 };
+
 /**
  * Takes a record of {NCS Feature Flag Names → boolean} and a supported product name.
  * Returns the corresponding product’s Launch Darkly Keys for each of the flags set as true in the input record.
  * */
-
-
 export var getProductSpecificFeatureFlags = function getProductSpecificFeatureFlags(flags, product) {
   var ncsFeatureFlags = filterFeatureFlagNames(flags);
   return ncsFeatureFlags.map(function (key) {
@@ -43,6 +39,5 @@ export function getCollabProviderFeatureFlag(flagName, featureFlags) {
   if (featureFlags) {
     return flagName in featureFlags ? featureFlags[flagName] : defaultNCSFeatureFlags[flagName];
   }
-
   return defaultNCSFeatureFlags[flagName];
 }

package/dist/esm/feature-flags/types.js

@@ -1,3 +1,5 @@
 // NCS feature flags - type and defaults defined here in one source of truth
+
 // With this type we ensure the object will contain all the flags
+
 export var supportedProducts = ['confluence'];

package/dist/esm/helpers/const.js

@@ -1,38 +1,29 @@
-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["RECONNECTION"] = "reconnection";
   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["MEASURE_PERFORMANCE"] = "measurePerformance";
+  EVENT_ACTION["INIT_UFO_EXPERIENCE"] = "initUFOExperience";
+  EVENT_ACTION["PUBLISH_PAGE"] = "publishPage";
 })(EVENT_ACTION || (EVENT_ACTION = {}));
-
 export var EVENT_STATUS;
-
 (function (EVENT_STATUS) {
   EVENT_STATUS["SUCCESS"] = "SUCCESS";
   EVENT_STATUS["FAILURE"] = "FAILURE";
 })(EVENT_STATUS || (EVENT_STATUS = {}));
-
 export var ADD_STEPS_TYPE;
-
 (function (ADD_STEPS_TYPE) {
   ADD_STEPS_TYPE["ACCEPTED"] = "ACCEPTED";
   ADD_STEPS_TYPE["REJECTED"] = "REJECTED";
   ADD_STEPS_TYPE["ERROR"] = "ERROR";
 })(ADD_STEPS_TYPE || (ADD_STEPS_TYPE = {}));
-
 export var ACK_MAX_TRY = 30;
 export var CONFLUENCE = 'confluence';

package/dist/esm/helpers/utils.js

@@ -2,7 +2,6 @@ export var createLogger = function createLogger(prefix) {
   var color = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'blue';
   return function (msg) {
     var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
     if (window.COLLAB_PROVIDER_LOGGER) {
       // eslint-disable-next-line no-console
       console.log("%cCollab-".concat(prefix, ": ").concat(msg), "color: ".concat(color, "; font-weight: bold"), data);
@@ -26,11 +25,9 @@ export function sleep(ms) {
 }
 export var getProduct = function getProduct(productInfo) {
   var _productInfo$product;
-
   return (_productInfo$product = productInfo === null || productInfo === void 0 ? void 0 : productInfo.product) !== null && _productInfo$product !== void 0 ? _productInfo$product : 'unknown';
 };
 export var getSubProduct = function getSubProduct(productInfo) {
   var _productInfo$subProdu;
-
   return (_productInfo$subProdu = productInfo === null || productInfo === void 0 ? void 0 : productInfo.subProduct) !== null && _productInfo$subProdu !== void 0 ? _productInfo$subProdu : !!(productInfo !== null && productInfo !== void 0 && productInfo.product) ? 'none' : 'unknown';
 };

package/dist/esm/provider/catchup.js

@@ -1,32 +1,26 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 import { createLogger } from '../helpers/utils';
 import { StepMap, Mapping } from 'prosemirror-transform';
 var 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) {
   var newSteps = [];
-
   var _iterator = _createForOfIteratorHelper(steps),
-      _step;
-
+    _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var step = _step.value;
-      var newStep = step.map(mapping); // newStep could be null(means invalid after rebase) when can't rebase.
-
+      var newStep = step.map(mapping);
+      // newStep could be null(means invalid after rebase) when can't rebase.
       if (newStep) {
         newSteps.push(newStep);
       }
@@ -36,87 +30,93 @@ export function rebaseSteps(steps, mapping) {
   } finally {
     _iterator.f();
   }
-
   return newSteps;
 }
 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, 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) {
           case 0:
             _context.next = 2;
             return opt.fetchCatchup(opt.getCurrentPmVersion());
-
           case 2:
             _yield$opt$fetchCatch = _context.sent;
             doc = _yield$opt$fetchCatch.doc;
             serverStepMaps = _yield$opt$fetchCatch.stepMaps;
             serverVersion = _yield$opt$fetchCatch.version;
             metadata = _yield$opt$fetchCatch.metadata;
-
             if (doc) {
               currentPmVersion = opt.getCurrentPmVersion();
-
               if (typeof serverVersion === 'undefined') {
                 logger("Could not determine server version");
               } else if (serverVersion <= currentPmVersion) {
-                logger("Catchup steps we already have. Ignoring.");
+                // there are no step maps in this case after page recovery
+                unconfirmedSteps = opt.getUnconfirmedSteps(); // replace the entire document
+                logger("Replacing document: ".concat(doc));
+                logger("getting metadata: ".concat(metadata));
+                // Replace local document and version number
+                opt.updateDocumentWithMetadata({
+                  doc: JSON.parse(doc),
+                  version: serverVersion,
+                  metadata: metadata,
+                  reserveCursor: true
+                });
+                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
-                _ref2 = opt.getUnconfirmedSteps() || {
-                  steps: []
-                }, unconfirmedSteps = _ref2.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
                  * the version we received from service. Keep steps that might be
                  * newer.
                  */
-
                 opt.filterQueue(function (data) {
                   return data.version > serverVersion;
-                }); // We are too far behind - replace the entire document
+                });
 
+                // We are too far behind - replace the entire document
                 logger("Replacing document: ".concat(doc));
-                logger("getting metadata: ".concat(metadata)); // Replace local document and version number
+                logger("getting metadata: ".concat(metadata));
 
+                // Replace local document and version number
                 opt.updateDocumentWithMetadata({
                   doc: JSON.parse(doc),
                   version: serverVersion,
                   metadata: metadata,
                   reserveCursor: true
-                }); // After replacing the whole document in the editor, we need to reapply the unconfirmed
+                });
+
+                // 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) {
+                if (_unconfirmedSteps !== null && _unconfirmedSteps !== void 0 && _unconfirmedSteps.length) {
                   // Create StepMap from StepMap JSON
                   // eslint-disable-next-line no-unused-vars
-                  stepMaps = serverStepMaps.map(function (_ref3) {
-                    var ranges = _ref3.ranges,
-                        inverted = _ref3.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);
                     stepMap.inverted = inverted;
                     return stepMap;
                   }); // create Mappng used for Step.map
-
                   mapping = new Mapping(stepMaps);
-                  logger("".concat(unconfirmedSteps.length, " unconfirmed steps before rebased: ").concat(JSON.stringify(unconfirmedSteps)));
-                  newUnconfirmedSteps = rebaseSteps(unconfirmedSteps, mapping);
-                  logger("Re-aply ".concat(newUnconfirmedSteps.length, " mapped unconfirmed steps: ").concat(JSON.stringify(newUnconfirmedSteps))); // Re-aply local steps
-
+                  logger("".concat(_unconfirmedSteps.length, " unconfirmed steps before rebased: ").concat(JSON.stringify(_unconfirmedSteps)));
+                  newUnconfirmedSteps = rebaseSteps(_unconfirmedSteps, mapping);
+                  logger("Re-aply ".concat(newUnconfirmedSteps.length, " mapped unconfirmed steps: ").concat(JSON.stringify(newUnconfirmedSteps)));
+                  // Re-aply local steps
                   opt.applyLocalSteps(newUnconfirmedSteps);
                 }
               }
             }
-
           case 8:
           case "end":
             return _context.stop();
@@ -124,7 +124,6 @@ export var catchup = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-
   return function catchup(_x) {
     return _ref.apply(this, arguments);
   };

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

@@ -0,0 +1,58 @@
+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();
+  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');
+    }
+  });
+};