@atlaskit/editor-plugin-collab-edit 0.1.0

package/dist/cjs/plugin-state.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginState = void 0;
+Object.defineProperty(exports, "TELEPOINTER_DIM_CLASS", {
+  enumerable: true,
+  get: function get() {
+    return _collab.TELEPOINTER_DIM_CLASS;
+  }
+});
+exports.getValidPos = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _collab = require("@atlaskit/editor-common/collab");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var _participants = require("./participants");
+var _utils2 = require("./utils");
+var isReplaceStep = function isReplaceStep(step) {
+  return step instanceof _transform.ReplaceStep;
+};
+/**
+ * Returns position where it's possible to place a decoration.
+ */
+var getValidPos = exports.getValidPos = function getValidPos(tr, pos) {
+  var endOfDocPos = tr.doc.nodeSize - 2;
+  if (pos <= endOfDocPos) {
+    var resolvedPos = tr.doc.resolve(pos);
+    var backwardSelection = _state.Selection.findFrom(resolvedPos, -1, true);
+    // if there's no correct cursor position before the `pos`, we try to find it after the `pos`
+    var forwardSelection = _state.Selection.findFrom(resolvedPos, 1, true);
+    return backwardSelection ? backwardSelection.from : forwardSelection ? forwardSelection.from : pos;
+  }
+  return endOfDocPos;
+};
+var PluginState = exports.PluginState = /*#__PURE__*/function () {
+  function PluginState(decorations, participants, sessionId) {
+    var collabInitalised = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var onError = arguments.length > 4 ? arguments[4] : undefined;
+    (0, _classCallCheck2.default)(this, PluginState);
+    // eslint-disable-next-line no-console
+    (0, _defineProperty2.default)(this, "onError", function (error) {
+      return console.error(error);
+    });
+    this.decorationSet = decorations;
+    this.participants = participants;
+    this.sid = sessionId;
+    this.isReady = collabInitalised;
+    this.onError = onError || this.onError;
+  }
+  (0, _createClass2.default)(PluginState, [{
+    key: "decorations",
+    get: function get() {
+      return this.decorationSet;
+    }
+  }, {
+    key: "activeParticipants",
+    get: function get() {
+      return this.participants;
+    }
+  }, {
+    key: "sessionId",
+    get: function get() {
+      return this.sid;
+    }
+  }, {
+    key: "getInitial",
+    value: function getInitial(sessionId) {
+      var participant = this.participants.get(sessionId);
+      return participant ? participant.name.substring(0, 1).toUpperCase() : 'X';
+    }
+  }, {
+    key: "apply",
+    value: function apply(tr) {
+      var _this = this;
+      var participants = this.participants,
+        sid = this.sid,
+        isReady = this.isReady;
+      var presenceData = tr.getMeta('presence');
+      var telepointerData = tr.getMeta('telepointer');
+      var sessionIdData = tr.getMeta('sessionId');
+      var collabInitialised = tr.getMeta('collabInitialised');
+      if (typeof collabInitialised !== 'boolean') {
+        collabInitialised = isReady;
+      }
+      if (sessionIdData) {
+        sid = sessionIdData.sid;
+      }
+      var add = [];
+      var remove = [];
+      if (presenceData) {
+        var _presenceData$joined = presenceData.joined,
+          joined = _presenceData$joined === void 0 ? [] : _presenceData$joined,
+          _presenceData$left = presenceData.left,
+          left = _presenceData$left === void 0 ? [] : _presenceData$left;
+        participants = participants.remove(left.map(function (i) {
+          return i.sessionId;
+        }));
+        participants = participants.add(joined);
+
+        // Remove telepointers for users that left
+        left.forEach(function (i) {
+          var pointers = (0, _utils2.findPointers)(i.sessionId, _this.decorationSet);
+          if (pointers) {
+            remove = remove.concat(pointers);
+          }
+        });
+      }
+      if (telepointerData) {
+        var sessionId = telepointerData.sessionId;
+        if (participants.get(sessionId) && sessionId !== sid) {
+          var oldPointers = (0, _utils2.findPointers)(telepointerData.sessionId, this.decorationSet);
+          if (oldPointers) {
+            remove = remove.concat(oldPointers);
+          }
+          var endOfDocPos = tr.doc.nodeSize - 2;
+          var anchor = telepointerData.selection.anchor;
+          var head = telepointerData.selection.head;
+          var rawFrom = anchor < head ? anchor : head;
+          var rawTo = anchor >= head ? anchor : head;
+          if (rawFrom > endOfDocPos) {
+            rawFrom = endOfDocPos;
+          }
+          if (rawTo > endOfDocPos) {
+            rawTo = endOfDocPos;
+          }
+          var isSelection = rawTo - rawFrom > 0;
+          var from = 1;
+          var to = 1;
+          try {
+            from = getValidPos(tr, isSelection ? Math.max(rawFrom - 1, 0) : rawFrom);
+            to = isSelection ? getValidPos(tr, rawTo) : from;
+          } catch (err) {
+            this.onError(err);
+          }
+          add = add.concat((0, _utils2.createTelepointers)(from, to, sessionId, isSelection, this.getInitial(sessionId)));
+        }
+      }
+      if (tr.docChanged) {
+        // Adjust decoration positions to changes made by the transaction
+        try {
+          this.decorationSet = this.decorationSet.map(tr.mapping, tr.doc, {
+            // Reapplies decorators those got removed by the state change
+            onRemove: function onRemove(spec) {
+              if (spec.pointer && spec.pointer.sessionId && spec.key === "telepointer-".concat(spec.pointer.sessionId)) {
+                var step = tr.steps.filter(isReplaceStep)[0];
+                if (step) {
+                  var _sessionId = spec.pointer.sessionId;
+                  var _ref = step,
+                    size = _ref.slice.content.size,
+                    _from = _ref.from;
+                  var pos = getValidPos(tr, size ? Math.min(_from + size, tr.doc.nodeSize - 3) : Math.max(_from, 1));
+                  add = add.concat((0, _utils2.createTelepointers)(pos, pos, _sessionId, false, _this.getInitial(_sessionId)));
+                }
+              }
+            }
+          });
+        } catch (err) {
+          this.onError(err);
+        }
+
+        // Remove any selection decoration within the change range,
+        // takes care of the issue when after pasting we end up with a dead selection
+        tr.steps.filter(isReplaceStep).forEach(function (s) {
+          var _ref2 = s,
+            from = _ref2.from,
+            to = _ref2.to;
+          _this.decorationSet.find(from, to).forEach(function (deco) {
+            // `type` is private, `from` and `to` are public in latest version
+            // `from` != `to` means it's a selection
+            if (deco.from !== deco.to) {
+              remove.push(deco);
+            }
+          });
+        });
+      }
+      var selection = tr.selection;
+      this.decorationSet.find().forEach(function (deco) {
+        if (deco.type.toDOM) {
+          var hasTelepointerDimClass = deco.type.toDOM.classList.contains(_collab.TELEPOINTER_DIM_CLASS);
+          if (deco.from === selection.from && deco.to === selection.to) {
+            if (!hasTelepointerDimClass) {
+              deco.type.toDOM.classList.add(_collab.TELEPOINTER_DIM_CLASS);
+            }
+
+            // Browser condition here to fix ED-14722 where telepointer
+            // decorations with side -1 in Firefox causes backspace issues.
+            // This is likely caused by contenteditable quirks in Firefox
+            if (!_utils.browser.gecko) {
+              deco.type.side = -1;
+            }
+          } else {
+            if (hasTelepointerDimClass) {
+              deco.type.toDOM.classList.remove(_collab.TELEPOINTER_DIM_CLASS);
+            }
+            deco.type.side = 0;
+          }
+        }
+      });
+      if (remove.length) {
+        this.decorationSet = this.decorationSet.remove(remove);
+      }
+      if (add.length) {
+        this.decorationSet = this.decorationSet.add(tr.doc, add);
+      }
+
+      // This piece needs to be after the decorationSet adjustments,
+      // otherwise it's always one step behind where the cursor is
+      if (telepointerData) {
+        var _sessionId2 = telepointerData.sessionId;
+        if (participants.get(_sessionId2)) {
+          var positionForScroll = (0, _utils2.getPositionOfTelepointer)(_sessionId2, this.decorationSet);
+          if (positionForScroll) {
+            participants = participants.updateCursorPos(_sessionId2, positionForScroll);
+          }
+        }
+      }
+      var nextState = new PluginState(this.decorationSet, participants, sid, collabInitialised);
+      return PluginState.eq(nextState, this) ? this : nextState;
+    }
+  }], [{
+    key: "eq",
+    value: function eq(a, b) {
+      return a.participants === b.participants && a.sessionId === b.sessionId && a.isReady === b.isReady;
+    }
+  }, {
+    key: "init",
+    value: function init(config) {
+      var doc = config.doc,
+        onError = config.onError;
+      return new PluginState(_view.DecorationSet.create(doc, []), new _participants.Participants(), undefined, undefined, onError);
+    }
+  }]);
+  return PluginState;
+}();

package/dist/cjs/plugin.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PluginState", {
+  enumerable: true,
+  get: function get() {
+    return _pluginState.PluginState;
+  }
+});
+exports.createPlugin = void 0;
+Object.defineProperty(exports, "pluginKey", {
+  enumerable: true,
+  get: function get() {
+    return _pluginKey.pluginKey;
+  }
+});
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _analytics2 = require("./analytics");
+var _initialize = require("./events/initialize");
+var _pluginKey = require("./plugin-key");
+var _pluginState = require("./plugin-state");
+var createPlugin = exports.createPlugin = function createPlugin(dispatch, providerFactory, providerResolver, collabProviderCallback, options, featureFlags, pluginInjectionApi) {
+  return new _safePlugin.SafePlugin({
+    key: _pluginKey.pluginKey,
+    state: {
+      init: function init(config) {
+        return _pluginState.PluginState.init(config);
+      },
+      apply: function apply(transaction, prevPluginState, _oldEditorState, _newEditorState) {
+        var pluginState = prevPluginState.apply(transaction);
+        dispatch(_pluginKey.pluginKey, pluginState);
+        return pluginState;
+      }
+    },
+    props: {
+      decorations: function decorations(state) {
+        var _pluginKey$getState;
+        return (_pluginKey$getState = _pluginKey.pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.decorations;
+      }
+    },
+    filterTransaction: function filterTransaction(tr, state) {
+      var pluginState = _pluginKey.pluginKey.getState(state);
+      var collabInitialiseTr = tr.getMeta('collabInitialised');
+
+      // Don't allow transactions that modifies the document before
+      // collab-plugin is ready.
+      if (collabInitialiseTr) {
+        return true;
+      }
+      if (!(pluginState !== null && pluginState !== void 0 && pluginState.isReady) && tr.docChanged) {
+        return false;
+      }
+      return true;
+    },
+    view: function view(_view) {
+      var _pluginInjectionApi$a, _pluginInjectionApi$a4;
+      var addErrorAnalytics = (0, _analytics2.addSynchronyErrorAnalytics)(_view.state, _view.state.tr, featureFlags, pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions);
+      var onSyncUpError = function onSyncUpError(attributes) {
+        var _pluginInjectionApi$a2, _pluginInjectionApi$a3;
+        var fireAnalyticsCallback = (0, _analytics.fireAnalyticsEvent)((_pluginInjectionApi$a2 = pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 || (_pluginInjectionApi$a3 = _pluginInjectionApi$a3.sharedState.currentState()) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : _pluginInjectionApi$a3.createAnalyticsEvent) !== null && _pluginInjectionApi$a2 !== void 0 ? _pluginInjectionApi$a2 : undefined);
+        fireAnalyticsCallback({
+          payload: {
+            action: _analytics.ACTION.NEW_COLLAB_SYNC_UP_ERROR_NO_STEPS,
+            actionSubject: _analytics.ACTION_SUBJECT.EDITOR,
+            eventType: _analytics.EVENT_TYPE.OPERATIONAL,
+            attributes: attributes
+          }
+        });
+      };
+      options.onSyncUpError = onSyncUpError;
+      var cleanup = collabProviderCallback((0, _initialize.initialize)({
+        view: _view,
+        options: options,
+        providerFactory: providerFactory,
+        featureFlags: featureFlags,
+        editorAnalyticsApi: pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a4 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.actions
+      }), addErrorAnalytics);
+      providerFactory && providerFactory.subscribe('collabEditProvider', function (_name, providerPromise) {
+        if (providerPromise) {
+          providerPromise.then(function (provider) {
+            return providerResolver(provider);
+          });
+        }
+      });
+      return {
+        destroy: function destroy() {
+          providerFactory.unsubscribeAll('collabEditProvider');
+          if (cleanup) {
+            cleanup.then(function (unsubscribe) {
+              if (unsubscribe) {
+                unsubscribe();
+              }
+            });
+          }
+        }
+      };
+    }
+  });
+};

package/dist/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/utils.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "colors", {
+  enumerable: true,
+  get: function get() {
+    return _collab.colors;
+  }
+});
+exports.findPointers = exports.createTelepointers = void 0;
+exports.getAvatarColor = getAvatarColor;
+exports.scrollToCollabCursor = exports.replaceDocument = exports.getPositionOfTelepointer = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _collab = require("@atlaskit/editor-common/collab");
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _view = require("@atlaskit/editor-prosemirror/view");
+var findPointers = exports.findPointers = function findPointers(id, decorations) {
+  return decorations.find().reduce(function (arr, deco) {
+    return deco.spec.pointer.sessionId === id ? arr.concat(deco) : arr;
+  }, []);
+};
+function style(options) {
+  var color = options && options.color || 'black';
+  return "border-left: 1px solid ".concat(color, "; border-right: 1px solid ").concat(color, "; margin-right: -2px;");
+}
+function getAvatarColor(str) {
+  var hash = 0;
+  for (var i = 0; i < str.length; i++) {
+    /* eslint-disable no-bitwise */
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash = hash & hash;
+    /* eslint-enable no-bitwise */
+  }
+
+  var index = Math.abs(hash) % _collab.colors.length;
+  return {
+    index: index,
+    color: _collab.colors[index]
+  };
+}
+var createTelepointers = exports.createTelepointers = function createTelepointers(from, to, sessionId, isSelection, initial) {
+  var decorations = [];
+  var avatarColor = getAvatarColor(sessionId);
+  var color = avatarColor.index.toString();
+  if (isSelection) {
+    var className = "telepointer color-".concat(color, " telepointer-selection");
+    decorations.push(_view.Decoration.inline(from, to, {
+      class: className,
+      'data-initial': initial
+    }, {
+      pointer: {
+        sessionId: sessionId
+      }
+    }));
+  }
+  var spaceJoinerBefore = document.createElement('span');
+  spaceJoinerBefore.textContent = _utils.ZERO_WIDTH_JOINER;
+  var spaceJoinerAfter = document.createElement('span');
+  spaceJoinerAfter.textContent = _utils.ZERO_WIDTH_JOINER;
+  var cursor = document.createElement('span');
+  cursor.textContent = _utils.ZERO_WIDTH_JOINER;
+  cursor.className = "telepointer color-".concat(color, " telepointer-selection-badge");
+  cursor.style.cssText = "".concat(style({
+    color: avatarColor.color.solid
+  }), ";");
+  cursor.setAttribute('data-initial', initial);
+  return decorations.concat(_view.Decoration.widget(to, spaceJoinerAfter, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId, "-zero")
+  })).concat(_view.Decoration.widget(to, cursor, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId)
+  })).concat(_view.Decoration.widget(to, spaceJoinerBefore, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId, "-zero")
+  }));
+};
+var replaceDocument = exports.replaceDocument = function replaceDocument(doc, state, version, options, reserveCursor) {
+  var schema = state.schema,
+    tr = state.tr;
+  var content = (doc.content || []).map(function (child) {
+    return schema.nodeFromJSON(child);
+  });
+  var hasContent = !!content.length;
+  if (hasContent) {
+    tr.setMeta('addToHistory', false);
+    tr.replaceWith(0, state.doc.nodeSize - 2, content);
+    var selection = state.selection;
+    if (reserveCursor) {
+      // If the cursor is still in the range of the new document,
+      // keep where it was.
+      if (selection.to < tr.doc.content.size - 2) {
+        var $from = tr.doc.resolve(selection.from);
+        var $to = tr.doc.resolve(selection.to);
+        var newselection = new _state.TextSelection($from, $to);
+        tr.setSelection(newselection);
+      }
+    } else {
+      tr.setSelection(_state.Selection.atStart(tr.doc));
+    }
+    tr.setMeta('replaceDocument', true);
+    if ((0, _typeof2.default)(version) !== undefined && options && options.useNativePlugin) {
+      var collabState = {
+        version: version,
+        unconfirmed: []
+      };
+      tr.setMeta('collab$', collabState);
+    }
+  }
+  return tr;
+};
+var scrollToCollabCursor = exports.scrollToCollabCursor = function scrollToCollabCursor(editorView, participants, sessionId, index, editorAnalyticsAPI) {
+  var selectedUser = participants[index];
+  if (selectedUser && selectedUser.cursorPos !== undefined && selectedUser.sessionId !== sessionId) {
+    var state = editorView.state;
+    var tr = state.tr;
+    var analyticsPayload = {
+      action: _analytics.ACTION.MATCHED,
+      actionSubject: _analytics.ACTION_SUBJECT.SELECTION,
+      eventType: _analytics.EVENT_TYPE.TRACK
+    };
+    tr.setSelection(_state.Selection.near(tr.doc.resolve(selectedUser.cursorPos)));
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent(analyticsPayload)(tr);
+    tr.scrollIntoView();
+    editorView.dispatch(tr);
+    if (!editorView.hasFocus()) {
+      editorView.focus();
+    }
+  }
+};
+var getPositionOfTelepointer = exports.getPositionOfTelepointer = function getPositionOfTelepointer(sessionId, decorationSet) {
+  var scrollPosition;
+  decorationSet.find().forEach(function (deco) {
+    if (deco.type.spec.pointer.sessionId === sessionId) {
+      scrollPosition = deco.from;
+    }
+  });
+  return scrollPosition;
+};

package/dist/es2019/actions.js

@@ -0,0 +1,119 @@
+import { receiveTransaction } from 'prosemirror-collab';
+import { AllSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { Step } from '@atlaskit/editor-prosemirror/transform';
+import { replaceDocument } from './utils';
+export const handleInit = (initData, view, options) => {
+  const {
+    doc,
+    json,
+    version,
+    reserveCursor
+  } = initData;
+  if (doc) {
+    const {
+      state
+    } = view;
+    const tr = replaceDocument(doc, state, version, options, reserveCursor);
+    tr.setMeta('isRemote', true);
+    view.dispatch(tr);
+  } else if (json) {
+    applyRemoteSteps(json, view);
+  }
+};
+export const handleConnection = (connectionData, view) => {
+  const {
+    state: {
+      tr
+    }
+  } = view;
+  view.dispatch(tr.setMeta('sessionId', connectionData));
+};
+export const handlePresence = (presenceData, view) => {
+  const {
+    state: {
+      tr
+    }
+  } = view;
+  view.dispatch(tr.setMeta('presence', presenceData));
+};
+export const applyRemoteData = (remoteData, view, options) => {
+  const {
+    json,
+    userIds = []
+  } = remoteData;
+  if (json) {
+    applyRemoteSteps(json, view, userIds, options);
+  }
+};
+export const applyRemoteSteps = (json, view, userIds, options) => {
+  if (!json || !json.length) {
+    return;
+  }
+  const {
+    state,
+    state: {
+      schema
+    }
+  } = view;
+  const steps = json.map(step => Step.fromJSON(schema, step));
+  let tr;
+  if (options && options.useNativePlugin && userIds) {
+    tr = receiveTransaction(state, steps, userIds);
+  } else {
+    tr = state.tr;
+    steps.forEach(step => tr.step(step));
+  }
+  if (tr) {
+    tr.setMeta('addToHistory', false);
+    tr.setMeta('isRemote', true);
+    const {
+      from,
+      to
+    } = state.selection;
+    const [firstStep] = json;
+
+    /*
+     * Persist marks across transactions. Fixes an issue where
+     * marks are lost if remote transactions are dispatched
+     * between a user creating the mark and typing.
+     */
+    if (state.tr.storedMarks) {
+      tr.setStoredMarks(state.tr.storedMarks);
+    }
+
+    /**
+     * If the cursor is a the same position as the first step in
+     * the remote data, we need to manually set it back again
+     * in order to prevent the cursor from moving.
+     */
+    if (from === firstStep.from && to === firstStep.to) {
+      tr.setSelection(state.selection.map(tr.doc, tr.mapping));
+    }
+    view.dispatch(tr);
+  }
+};
+export const handleTelePointer = (telepointerData, view) => {
+  const {
+    state: {
+      tr
+    }
+  } = view;
+  view.dispatch(tr.setMeta('telepointer', telepointerData));
+};
+function isAllSelection(selection) {
+  return selection instanceof AllSelection;
+}
+function isNodeSelection(selection) {
+  return selection instanceof NodeSelection;
+}
+export const getSendableSelection = selection => {
+  /**
+   * <kbd>CMD + A</kbd> triggers a AllSelection
+   * <kbd>escape</kbd> triggers a NodeSelection
+   */
+  return {
+    type: 'textSelection',
+    anchor: selection.anchor,
+    head: isAllSelection(selection) || isNodeSelection(selection) ? selection.head - 1 : selection.head
+  };
+};

package/dist/es2019/analytics.js

@@ -0,0 +1,41 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { getDocStructure } from '@atlaskit/editor-common/core-utils';
+import { sniffUserBrowserExtensions } from '@atlaskit/editor-common/utils';
+export const addSynchronyErrorAnalytics = (state, tr, featureFlags, editorAnalyticsApi) => {
+  return error => {
+    const browserExtensions = sniffUserBrowserExtensions({
+      extensions: ['grammarly']
+    });
+    const payload = {
+      action: ACTION.SYNCHRONY_ERROR,
+      actionSubject: ACTION_SUBJECT.EDITOR,
+      eventType: EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        error,
+        browserExtensions
+      }
+    };
+    if (featureFlags.synchronyErrorDocStructure) {
+      payload.attributes.docStructure = getDocStructure(state.doc, {
+        compact: true
+      });
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(payload)(tr);
+    return tr;
+  };
+};
+export const addSynchronyEntityAnalytics = (state, tr) => {
+  return (type, editorAnalyticsApi) => {
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+      action: type === 'error' ? ACTION.SYNCHRONY_ENTITY_ERROR : ACTION.SYNCHRONY_DISCONNECTED,
+      actionSubject: ACTION_SUBJECT.EDITOR,
+      eventType: EVENT_TYPE.OPERATIONAL,
+      attributes: {
+        // https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine
+        onLine: navigator.onLine,
+        visibilityState: document.visibilityState
+      }
+    })(tr);
+    return tr;
+  };
+};