@atlaskit/editor-plugin-collab-edit 0.1.0

package/dist/esm/participants.js

@@ -0,0 +1,88 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+export var Participants = /*#__PURE__*/function () {
+  function Participants() {
+    var participants = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Map();
+    _classCallCheck(this, Participants);
+    this.participants = participants;
+  }
+  _createClass(Participants, [{
+    key: "add",
+    value: function add(data) {
+      var newSet = new Map(this.participants);
+      data.forEach(function (participant) {
+        newSet.set(participant.sessionId, participant);
+      });
+      return new Participants(newSet);
+    }
+  }, {
+    key: "remove",
+    value: function remove(sessionIds) {
+      var newSet = new Map(this.participants);
+      sessionIds.forEach(function (sessionId) {
+        newSet.delete(sessionId);
+      });
+      return new Participants(newSet);
+    }
+  }, {
+    key: "update",
+    value: function update(sessionId, lastActive) {
+      var newSet = new Map(this.participants);
+      var data = newSet.get(sessionId);
+      if (!data) {
+        return this;
+      }
+      newSet.set(sessionId, _objectSpread(_objectSpread({}, data), {}, {
+        lastActive: lastActive
+      }));
+      return new Participants(newSet);
+    }
+  }, {
+    key: "updateCursorPos",
+    value: function updateCursorPos(sessionId, cursorPos) {
+      var newSet = new Map(this.participants);
+      var data = newSet.get(sessionId);
+      if (!data) {
+        return this;
+      }
+      newSet.set(sessionId, _objectSpread(_objectSpread({}, data), {}, {
+        cursorPos: cursorPos
+      }));
+      return new Participants(newSet);
+    }
+  }, {
+    key: "toArray",
+    value: function toArray() {
+      return Array.from(this.participants.values());
+    }
+  }, {
+    key: "get",
+    value: function get(sessionId) {
+      return this.participants.get(sessionId);
+    }
+  }, {
+    key: "size",
+    value: function size() {
+      return this.participants.size;
+    }
+  }, {
+    key: "eq",
+    value: function eq(other) {
+      var left = this.toArray().map(function (p) {
+        return p.sessionId;
+      }).sort(function (a, b) {
+        return a > b ? -1 : 1;
+      }).join('');
+      var right = other.toArray().map(function (p) {
+        return p.sessionId;
+      }).sort(function (a, b) {
+        return a > b ? -1 : 1;
+      }).join('');
+      return left === right;
+    }
+  }]);
+  return Participants;
+}();

package/dist/esm/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var pluginKey = new PluginKey('collabEditPlugin');

package/dist/esm/plugin-state.js

@@ -0,0 +1,229 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { TELEPOINTER_DIM_CLASS } from '@atlaskit/editor-common/collab';
+import { browser } from '@atlaskit/editor-common/utils';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Participants } from './participants';
+import { createTelepointers, findPointers, getPositionOfTelepointer } from './utils';
+var isReplaceStep = function isReplaceStep(step) {
+  return step instanceof ReplaceStep;
+};
+export { TELEPOINTER_DIM_CLASS };
+
+/**
+ * Returns position where it's possible to place a decoration.
+ */
+export var getValidPos = function getValidPos(tr, pos) {
+  var endOfDocPos = tr.doc.nodeSize - 2;
+  if (pos <= endOfDocPos) {
+    var resolvedPos = tr.doc.resolve(pos);
+    var backwardSelection = 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 = Selection.findFrom(resolvedPos, 1, true);
+    return backwardSelection ? backwardSelection.from : forwardSelection ? forwardSelection.from : pos;
+  }
+  return endOfDocPos;
+};
+export var 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;
+    _classCallCheck(this, PluginState);
+    // eslint-disable-next-line no-console
+    _defineProperty(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;
+  }
+  _createClass(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 = 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 = 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(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(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(TELEPOINTER_DIM_CLASS);
+          if (deco.from === selection.from && deco.to === selection.to) {
+            if (!hasTelepointerDimClass) {
+              deco.type.toDOM.classList.add(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 (!browser.gecko) {
+              deco.type.side = -1;
+            }
+          } else {
+            if (hasTelepointerDimClass) {
+              deco.type.toDOM.classList.remove(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 = 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(DecorationSet.create(doc, []), new Participants(), undefined, undefined, onError);
+    }
+  }]);
+  return PluginState;
+}();

package/dist/esm/plugin.js

@@ -0,0 +1,85 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { addSynchronyErrorAnalytics } from './analytics';
+import { initialize } from './events/initialize';
+import { pluginKey } from './plugin-key';
+import { PluginState } from './plugin-state';
+export { PluginState, pluginKey };
+export var createPlugin = function createPlugin(dispatch, providerFactory, providerResolver, collabProviderCallback, options, featureFlags, pluginInjectionApi) {
+  return new SafePlugin({
+    key: pluginKey,
+    state: {
+      init: function init(config) {
+        return PluginState.init(config);
+      },
+      apply: function apply(transaction, prevPluginState, _oldEditorState, _newEditorState) {
+        var pluginState = prevPluginState.apply(transaction);
+        dispatch(pluginKey, pluginState);
+        return pluginState;
+      }
+    },
+    props: {
+      decorations: function decorations(state) {
+        var _pluginKey$getState;
+        return (_pluginKey$getState = pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.decorations;
+      }
+    },
+    filterTransaction: function filterTransaction(tr, state) {
+      var pluginState = 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 = 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 = 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: ACTION.NEW_COLLAB_SYNC_UP_ERROR_NO_STEPS,
+            actionSubject: ACTION_SUBJECT.EDITOR,
+            eventType: EVENT_TYPE.OPERATIONAL,
+            attributes: attributes
+          }
+        });
+      };
+      options.onSyncUpError = onSyncUpError;
+      var cleanup = collabProviderCallback(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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils.js

@@ -0,0 +1,136 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { colors } from '@atlaskit/editor-common/collab';
+import { ZERO_WIDTH_JOINER } from '@atlaskit/editor-common/utils';
+import { Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+export { colors };
+export var 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;");
+}
+export 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) % colors.length;
+  return {
+    index: index,
+    color: colors[index]
+  };
+}
+export var 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(Decoration.inline(from, to, {
+      class: className,
+      'data-initial': initial
+    }, {
+      pointer: {
+        sessionId: sessionId
+      }
+    }));
+  }
+  var spaceJoinerBefore = document.createElement('span');
+  spaceJoinerBefore.textContent = ZERO_WIDTH_JOINER;
+  var spaceJoinerAfter = document.createElement('span');
+  spaceJoinerAfter.textContent = ZERO_WIDTH_JOINER;
+  var cursor = document.createElement('span');
+  cursor.textContent = 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(Decoration.widget(to, spaceJoinerAfter, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId, "-zero")
+  })).concat(Decoration.widget(to, cursor, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId)
+  })).concat(Decoration.widget(to, spaceJoinerBefore, {
+    pointer: {
+      sessionId: sessionId
+    },
+    key: "telepointer-".concat(sessionId, "-zero")
+  }));
+};
+export var 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 TextSelection($from, $to);
+        tr.setSelection(newselection);
+      }
+    } else {
+      tr.setSelection(Selection.atStart(tr.doc));
+    }
+    tr.setMeta('replaceDocument', true);
+    if (_typeof(version) !== undefined && options && options.useNativePlugin) {
+      var collabState = {
+        version: version,
+        unconfirmed: []
+      };
+      tr.setMeta('collab$', collabState);
+    }
+  }
+  return tr;
+};
+export var 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: ACTION.MATCHED,
+      actionSubject: ACTION_SUBJECT.SELECTION,
+      eventType: EVENT_TYPE.TRACK
+    };
+    tr.setSelection(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();
+    }
+  }
+};
+export var 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/types/actions.d.ts

@@ -0,0 +1,11 @@
+import type { CollabEventConnectionData, CollabEventInitData, CollabEventPresenceData, CollabEventRemoteData, CollabSendableSelection, CollabTelepointerPayload } from '@atlaskit/editor-common/collab';
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PrivateCollabEditOptions } from './types';
+export declare const handleInit: (initData: CollabEventInitData, view: EditorView, options?: PrivateCollabEditOptions) => void;
+export declare const handleConnection: (connectionData: CollabEventConnectionData, view: EditorView) => void;
+export declare const handlePresence: (presenceData: CollabEventPresenceData, view: EditorView) => void;
+export declare const applyRemoteData: (remoteData: CollabEventRemoteData, view: EditorView, options: PrivateCollabEditOptions) => void;
+export declare const applyRemoteSteps: (json: any[], view: EditorView, userIds?: (number | string)[], options?: PrivateCollabEditOptions) => void;
+export declare const handleTelePointer: (telepointerData: CollabTelepointerPayload, view: EditorView) => void;
+export declare const getSendableSelection: (selection: Selection) => CollabSendableSelection;

package/dist/types/analytics.d.ts

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const addSynchronyErrorAnalytics: (state: EditorState, tr: Transaction, featureFlags: FeatureFlags, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => (error: Error) => Transaction;
+export type EntityEventType = 'error' | 'disconnected';
+export declare const addSynchronyEntityAnalytics: (state: EditorState, tr: Transaction) => (type: EntityEventType, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Transaction;

package/dist/types/events/handlers.d.ts

@@ -0,0 +1,24 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { CollabEditProvider, CollabEventConnectionData, CollabEventInitData, CollabEventLocalStepData, CollabEventPresenceData, CollabEventRemoteData, CollabTelepointerPayload } from '@atlaskit/editor-common/collab';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PrivateCollabEditOptions } from '../types';
+export type SynchronyEntity = {
+    on: (evt: 'disconnected' | 'error', handler: (...args: any) => void) => void;
+    off: (evt: 'disconnected' | 'error', handler: (...args: any) => void) => void;
+};
+export interface CollabHandlers {
+    initHandler: (data: CollabEventInitData) => void;
+    connectedHandler: (data: CollabEventConnectionData) => void;
+    dataHandler: (data: CollabEventRemoteData) => void;
+    presenceHandler: (data: CollabEventPresenceData) => void;
+    telepointerHandler: (data: CollabTelepointerPayload) => void;
+    localStepsHandler: (data: CollabEventLocalStepData) => void;
+    errorHandler: (error: any) => void;
+    entityHandler: ({ entity }: {
+        entity: SynchronyEntity;
+    }) => void;
+}
+export type Cleanup = () => void;
+export declare const subscribe: (currentDeps_0: EditorView, currentDeps_1: CollabEditProvider<import("@atlaskit/editor-common/collab").CollabEvents>, currentDeps_2: PrivateCollabEditOptions, currentDeps_3: FeatureFlags, currentDeps_4?: ProviderFactory | undefined, currentDeps_5?: EditorAnalyticsAPI | undefined) => Cleanup;

package/dist/types/events/initialize.d.ts

@@ -0,0 +1,16 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { CollabEditProvider } from '@atlaskit/editor-common/collab';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PrivateCollabEditOptions } from '../types';
+import type { Cleanup } from './handlers';
+type Props = {
+    view: EditorView;
+    options: PrivateCollabEditOptions;
+    providerFactory: ProviderFactory;
+    featureFlags: FeatureFlags;
+    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
+};
+export declare const initialize: ({ options, providerFactory, view, featureFlags, editorAnalyticsApi, }: Props) => (provider: CollabEditProvider) => Cleanup;
+export {};

package/dist/types/events/send-transaction.d.ts

@@ -0,0 +1,11 @@
+import type { CollabEditProvider } from '@atlaskit/editor-common/collab';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+type Props = {
+    originalTransaction: Readonly<Transaction>;
+    transactions: readonly Transaction[];
+    oldEditorState: EditorState;
+    newEditorState: EditorState;
+    useNativePlugin: boolean;
+};
+export declare const sendTransaction: ({ originalTransaction, transactions, oldEditorState, newEditorState, useNativePlugin, }: Props) => (provider: CollabEditProvider) => void;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { ReadOnlyParticipants } from './participants';
+import { pluginKey } from './plugin';
+import type { PrivateCollabEditOptions } from './types';
+export { pluginKey };
+import type { Color } from './utils';
+export type { PluginState } from './plugin-state';
+export type { CollabInviteToEditProps, InviteToEditComponentProps, PrivateCollabEditOptions, } from './types';
+export type { ReadOnlyParticipants } from './participants';
+export type CollabEditPlugin = NextEditorPlugin<'collabEdit', {
+    pluginConfiguration: PrivateCollabEditOptions;
+    dependencies: [
+        OptionalPlugin<FeatureFlagsPlugin>,
+        OptionalPlugin<AnalyticsPlugin>
+    ];
+    sharedState: {
+        activeParticipants: ReadOnlyParticipants | undefined;
+        sessionId: string | undefined;
+    } | undefined;
+    actions: {
+        getAvatarColor: (str: string) => {
+            index: number;
+            color: Color;
+        };
+    };
+}>;
+export declare const collabEditPlugin: CollabEditPlugin;

package/dist/types/native-collab-provider-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { CollabEditProvider, CollabEvents } from '@atlaskit/editor-common/collab';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export declare const nativeCollabProviderPlugin: ({ providerPromise, }: {
+    providerPromise: Promise<CollabEditProvider>;
+}) => SafePlugin<CollabEditProvider<CollabEvents> | null>;
+export declare const getCollabProvider: (editorState: EditorState) => CollabEditProvider | null;