@atlaskit/collab-provider 8.0.1 → 8.2.0

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

@@ -26,29 +26,27 @@ export var ErrorCodeMapper = {
   },
   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,17 +54,11 @@ export var errorCodeMapper = function errorCodeMapper(error) {
         code: ErrorCodeMapper.failToSave.code,
         message: ErrorCodeMapper.failToSave.message
       };
-
-    case 'CATCHUP_FAILED':
-    case 'GET_QUERY_TIME_OUT':
-    case 'INIT_DATA_LOAD_FAILED':
+    default:
       return {
         status: 500,
         code: ErrorCodeMapper.internalError.code,
         message: ErrorCodeMapper.internalError.message
       };
-
-    default:
-      break;
   }
 };

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

@@ -0,0 +1,25 @@
+import { getProductSpecificFeatureFlags, getCollabProviderFeatureFlag } from '../index';
+describe('Feature flags', function () {
+  it('getProductSpecificFeatureFlags', function () {
+    var result = getProductSpecificFeatureFlags({
+      testFF: true
+    }, 'confluence');
+    expect(result).toEqual(['confluence.fe.collab.provider.testFF']);
+  });
+  it('getCollabProviderFeatureFlag return true', function () {
+    var result = getCollabProviderFeatureFlag('testFF', {
+      testFF: true
+    });
+    expect(result).toEqual(true);
+  });
+  it('getCollabProviderFeatureFlag with wrong ff set', function () {
+    var result = getCollabProviderFeatureFlag('testFF', {
+      abc: true
+    });
+    expect(result).toEqual(false);
+  });
+  it('getCollabProviderFeatureFlag with wrong ff set', function () {
+    var result = getCollabProviderFeatureFlag('testFF', undefined);
+    expect(result).toEqual(false);
+  });
+});

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

@@ -0,0 +1,43 @@
+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];
+    return !!value;
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 1),
+      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) {
+    return productKeys[product][key];
+  });
+};
+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

@@ -0,0 +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,13 +1,10 @@
 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";
@@ -17,21 +14,19 @@ export var EVENT_ACTION;
   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 || (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 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,97 @@ 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, _ref2, unconfirmedSteps, _ref3, _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
+                _ref2 = opt.getUnconfirmedSteps() || {
+                  steps: []
+                }, unconfirmedSteps = _ref2.steps; // 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.length) {
+                  opt.applyLocalSteps(unconfirmedSteps);
+                }
               } else {
                 // Please, do not use those steps inside of async
                 // method. That will lead to outdated steps
-                _ref2 = opt.getUnconfirmedSteps() || {
+                _ref3 = opt.getUnconfirmedSteps() || {
                   steps: []
-                }, unconfirmedSteps = _ref2.steps;
+                }, _unconfirmedSteps = _ref3.steps;
                 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.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 (_ref4) {
+                    var ranges = _ref4.ranges,
+                      inverted = _ref4.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 +128,6 @@ export var catchup = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-
   return function catchup(_x) {
     return _ref.apply(this, arguments);
   };